G__Hist.cxx

Go to the documentation of this file.

//
// File generated by core/utils/src/rootcint_tmp at Wed Apr 20 13:34:07 2011

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

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

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

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

#ifndef G__ROOT
#define G__ROOT
#endif

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

#include "TBuffer.h"
#include "TVirtualObject.h"
#include <vector>
#include "TSchemaHelper.h"


// START OF SHADOWS

namespace ROOT {
   namespace Shadow {
      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::Foption_t Foption_t;
      #else
      class Foption_t  {
         public:
         //friend XX;
         int Quiet; //"Q"  Quiet mode. No print
         int Verbose; //"V"  Verbose mode. Print results after each iteration
         int Bound; //"B"  When using pre-defined functions user parameter settings are used instead of default one
         int Chi2; //"X"  For fitting THnsparse use chi2 method (default is likelihood)
         int Like; //"L"  Use Log Likelihood. Default is chisquare method except fitting THnsparse
         int User; //"U"  Use a User specified fitting algorithm (via SetFCN)
         int W1; //"W"  Set all the weights to 1. Ignore error bars
         int Errors; //"E"  Performs a better error evaluation, calling HESSE and MINOS
         int More; //"M"  Improve fit results.
         int Range; //"R"  Use the range stored in function
         int Gradient; //"G"  Option to compute derivatives analytically
         int Nostore; //"N"  If set, do not store the function graph
         int Nograph; //"0"  If set, do not display the function graph
         int Plus; //"+"  Add new function (default is replace)
         int Integral; //"I"  Use function integral instead of function in center of bin
         int Nochisq; //"C"  In case of linear fitting, don't calculate the chisquare
         int Minuit; //"F"  If fitting a polN, switch to minuit fitter
         int NoErrX; //"EX0" or "T" When fitting a TGraphErrors do not consider error in coordinates 
         int Robust; //"ROB" or "H":  For a TGraph use robust fitting
         int StoreResult; //"S": Stores the result in a TFitResult structure
         double hRobust; //value of h parameter used in robust fitting 
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::THnSparseT< ::TArrayD > THnSparseTlETArrayDgR;
      #else
      class THnSparseTlETArrayDgR  :  public ::THnSparse {
         public:
         //friend XX;
         // To force the creation of a virtual table, throw just in case.
         virtual ~THnSparseTlETArrayDgR() throw() {};
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::THnSparseT< ::TArrayF > THnSparseTlETArrayFgR;
      #else
      class THnSparseTlETArrayFgR  :  public ::THnSparse {
         public:
         //friend XX;
         // To force the creation of a virtual table, throw just in case.
         virtual ~THnSparseTlETArrayFgR() throw() {};
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::THnSparseT< ::TArrayL > THnSparseTlETArrayLgR;
      #else
      class THnSparseTlETArrayLgR  :  public ::THnSparse {
         public:
         //friend XX;
         // To force the creation of a virtual table, throw just in case.
         virtual ~THnSparseTlETArrayLgR() throw() {};
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::THnSparseT< ::TArrayI > THnSparseTlETArrayIgR;
      #else
      class THnSparseTlETArrayIgR  :  public ::THnSparse {
         public:
         //friend XX;
         // To force the creation of a virtual table, throw just in case.
         virtual ~THnSparseTlETArrayIgR() throw() {};
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::THnSparseT< ::TArrayS > THnSparseTlETArraySgR;
      #else
      class THnSparseTlETArraySgR  :  public ::THnSparse {
         public:
         //friend XX;
         // To force the creation of a virtual table, throw just in case.
         virtual ~THnSparseTlETArraySgR() throw() {};
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::THnSparseT< ::TArrayC > THnSparseTlETArrayCgR;
      #else
      class THnSparseTlETArrayCgR  :  public ::THnSparse {
         public:
         //friend XX;
         // To force the creation of a virtual table, throw just in case.
         virtual ~THnSparseTlETArrayCgR() throw() {};
      };
      #endif

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

namespace ROOT {
   void Foption_t_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void Foption_t_Dictionary();
   static void *new_Foption_t(void *p = 0);
   static void *newArray_Foption_t(Long_t size, void *p);
   static void delete_Foption_t(void *p);
   static void deleteArray_Foption_t(void *p);
   static void destruct_Foption_t(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::Foption_t*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::Foption_t) == sizeof(::ROOT::Shadow::Foption_t));
      ::Foption_t *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Foption_t),0);
      static ::ROOT::TGenericClassInfo 
         instance("Foption_t", "include/Foption.h", 24,
                  typeid(::Foption_t), DefineBehavior(ptr, ptr),
                  &Foption_t_ShowMembers, &Foption_t_Dictionary, isa_proxy, 4,
                  sizeof(::Foption_t) );
      instance.SetNew(&new_Foption_t);
      instance.SetNewArray(&newArray_Foption_t);
      instance.SetDelete(&delete_Foption_t);
      instance.SetDeleteArray(&deleteArray_Foption_t);
      instance.SetDestructor(&destruct_Foption_t);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::Foption_t*)
   {
      return GenerateInitInstanceLocal((::Foption_t*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::Foption_t*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   void TH1_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TH1(void *p);
   static void deleteArray_TH1(void *p);
   static void destruct_TH1(void *p);
   static void directoryAutoAdd_TH1(void *p, TDirectory *dir);
   static void streamer_TH1(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TH1*)
   {
      ::TH1 *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TH1 >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TH1", ::TH1::Class_Version(), "include/TH1.h", 77,
                  typeid(::TH1), DefineBehavior(ptr, ptr),
                  &::TH1::Dictionary, isa_proxy, 1,
                  sizeof(::TH1) );
      instance.SetDelete(&delete_TH1);
      instance.SetDeleteArray(&deleteArray_TH1);
      instance.SetDestructor(&destruct_TH1);
      instance.SetDirectoryAutoAdd(&directoryAutoAdd_TH1);
      instance.SetStreamerFunc(&streamer_TH1);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TH1*)
   {
      return GenerateInitInstanceLocal((::TH1*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TH1*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void THnSparse_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_THnSparse(void *p);
   static void deleteArray_THnSparse(void *p);
   static void destruct_THnSparse(void *p);

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

namespace ROOT {
   void TF1_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TF1(void *p = 0);
   static void *newArray_TF1(Long_t size, void *p);
   static void delete_TF1(void *p);
   static void deleteArray_TF1(void *p);
   static void destruct_TF1(void *p);
   static void streamer_TF1(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TF1*)
   {
      ::TF1 *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TF1 >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TF1", ::TF1::Class_Version(), "include/TF1.h", 54,
                  typeid(::TF1), DefineBehavior(ptr, ptr),
                  &::TF1::Dictionary, isa_proxy, 1,
                  sizeof(::TF1) );
      instance.SetNew(&new_TF1);
      instance.SetNewArray(&newArray_TF1);
      instance.SetDelete(&delete_TF1);
      instance.SetDeleteArray(&deleteArray_TF1);
      instance.SetDestructor(&destruct_TF1);
      instance.SetStreamerFunc(&streamer_TF1);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TF1*)
   {
      return GenerateInitInstanceLocal((::TF1*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TF1*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TF2_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TF2(void *p = 0);
   static void *newArray_TF2(Long_t size, void *p);
   static void delete_TF2(void *p);
   static void deleteArray_TF2(void *p);
   static void destruct_TF2(void *p);
   static void streamer_TF2(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TF2*)
   {
      ::TF2 *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TF2 >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TF2", ::TF2::Class_Version(), "include/TF2.h", 33,
                  typeid(::TF2), DefineBehavior(ptr, ptr),
                  &::TF2::Dictionary, isa_proxy, 1,
                  sizeof(::TF2) );
      instance.SetNew(&new_TF2);
      instance.SetNewArray(&newArray_TF2);
      instance.SetDelete(&delete_TF2);
      instance.SetDeleteArray(&deleteArray_TF2);
      instance.SetDestructor(&destruct_TF2);
      instance.SetStreamerFunc(&streamer_TF2);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TF2*)
   {
      return GenerateInitInstanceLocal((::TF2*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TF2*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGraph_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGraph(void *p = 0);
   static void *newArray_TGraph(Long_t size, void *p);
   static void delete_TGraph(void *p);
   static void deleteArray_TGraph(void *p);
   static void destruct_TGraph(void *p);
   static void streamer_TGraph(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGraph*)
   {
      ::TGraph *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGraph >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGraph", ::TGraph::Class_Version(), "include/TGraph.h", 53,
                  typeid(::TGraph), DefineBehavior(ptr, ptr),
                  &::TGraph::Dictionary, isa_proxy, 1,
                  sizeof(::TGraph) );
      instance.SetNew(&new_TGraph);
      instance.SetNewArray(&newArray_TGraph);
      instance.SetDelete(&delete_TGraph);
      instance.SetDeleteArray(&deleteArray_TGraph);
      instance.SetDestructor(&destruct_TGraph);
      instance.SetStreamerFunc(&streamer_TGraph);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGraph*)
   {
      return GenerateInitInstanceLocal((::TGraph*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGraph*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGraphErrors_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGraphErrors(void *p = 0);
   static void *newArray_TGraphErrors(Long_t size, void *p);
   static void delete_TGraphErrors(void *p);
   static void deleteArray_TGraphErrors(void *p);
   static void destruct_TGraphErrors(void *p);
   static void streamer_TGraphErrors(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGraphErrors*)
   {
      ::TGraphErrors *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGraphErrors >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGraphErrors", ::TGraphErrors::Class_Version(), "include/TGraphErrors.h", 28,
                  typeid(::TGraphErrors), DefineBehavior(ptr, ptr),
                  &::TGraphErrors::Dictionary, isa_proxy, 1,
                  sizeof(::TGraphErrors) );
      instance.SetNew(&new_TGraphErrors);
      instance.SetNewArray(&newArray_TGraphErrors);
      instance.SetDelete(&delete_TGraphErrors);
      instance.SetDeleteArray(&deleteArray_TGraphErrors);
      instance.SetDestructor(&destruct_TGraphErrors);
      instance.SetStreamerFunc(&streamer_TGraphErrors);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGraphErrors*)
   {
      return GenerateInitInstanceLocal((::TGraphErrors*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGraphErrors*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGraph2D_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGraph2D(void *p = 0);
   static void *newArray_TGraph2D(Long_t size, void *p);
   static void delete_TGraph2D(void *p);
   static void deleteArray_TGraph2D(void *p);
   static void destruct_TGraph2D(void *p);
   static void directoryAutoAdd_TGraph2D(void *p, TDirectory *dir);
   static void streamer_TGraph2D(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGraph2D*)
   {
      ::TGraph2D *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGraph2D >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGraph2D", ::TGraph2D::Class_Version(), "include/TGraph2D.h", 50,
                  typeid(::TGraph2D), DefineBehavior(ptr, ptr),
                  &::TGraph2D::Dictionary, isa_proxy, 1,
                  sizeof(::TGraph2D) );
      instance.SetNew(&new_TGraph2D);
      instance.SetNewArray(&newArray_TGraph2D);
      instance.SetDelete(&delete_TGraph2D);
      instance.SetDeleteArray(&deleteArray_TGraph2D);
      instance.SetDestructor(&destruct_TGraph2D);
      instance.SetDirectoryAutoAdd(&directoryAutoAdd_TGraph2D);
      instance.SetStreamerFunc(&streamer_TGraph2D);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGraph2D*)
   {
      return GenerateInitInstanceLocal((::TGraph2D*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGraph2D*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TMultiGraph_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMultiGraph(void *p = 0);
   static void *newArray_TMultiGraph(Long_t size, void *p);
   static void delete_TMultiGraph(void *p);
   static void deleteArray_TMultiGraph(void *p);
   static void destruct_TMultiGraph(void *p);

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

namespace ROOT {
   void TFitResult_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TFitResult(void *p = 0);
   static void *newArray_TFitResult(Long_t size, void *p);
   static void delete_TFitResult(void *p);
   static void deleteArray_TFitResult(void *p);
   static void destruct_TFitResult(void *p);

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

namespace ROOT {
   void TFitResultPtr_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TFitResultPtr(void *p = 0);
   static void *newArray_TFitResultPtr(Long_t size, void *p);
   static void delete_TFitResultPtr(void *p);
   static void deleteArray_TFitResultPtr(void *p);
   static void destruct_TFitResultPtr(void *p);

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

namespace ROOT {
namespace Fit {
   namespace ROOT {
      inline ::ROOT::TGenericClassInfo *GenerateInitInstance();
      static void ROOTcLcLFit_Dictionary();

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

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

   }
}
}

namespace ROOT {
   void TAxis_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TAxis(void *p = 0);
   static void *newArray_TAxis(Long_t size, void *p);
   static void delete_TAxis(void *p);
   static void deleteArray_TAxis(void *p);
   static void destruct_TAxis(void *p);
   static void streamer_TAxis(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TAxis*)
   {
      ::TAxis *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TAxis >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TAxis", ::TAxis::Class_Version(), "include/TAxis.h", 36,
                  typeid(::TAxis), DefineBehavior(ptr, ptr),
                  &::TAxis::Dictionary, isa_proxy, 1,
                  sizeof(::TAxis) );
      instance.SetNew(&new_TAxis);
      instance.SetNewArray(&newArray_TAxis);
      instance.SetDelete(&delete_TAxis);
      instance.SetDeleteArray(&deleteArray_TAxis);
      instance.SetDestructor(&destruct_TAxis);
      instance.SetStreamerFunc(&streamer_TAxis);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TAxis*)
   {
      return GenerateInitInstanceLocal((::TAxis*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TAxis*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TBackCompFitter_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TBackCompFitter(void *p = 0);
   static void *newArray_TBackCompFitter(Long_t size, void *p);
   static void delete_TBackCompFitter(void *p);
   static void deleteArray_TBackCompFitter(void *p);
   static void destruct_TBackCompFitter(void *p);

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

namespace ROOT {
   void TBinomialEfficiencyFitter_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TBinomialEfficiencyFitter(void *p = 0);
   static void *newArray_TBinomialEfficiencyFitter(Long_t size, void *p);
   static void delete_TBinomialEfficiencyFitter(void *p);
   static void deleteArray_TBinomialEfficiencyFitter(void *p);
   static void destruct_TBinomialEfficiencyFitter(void *p);

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

namespace ROOT {
   void TConfidenceLevel_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TConfidenceLevel(void *p = 0);
   static void *newArray_TConfidenceLevel(Long_t size, void *p);
   static void delete_TConfidenceLevel(void *p);
   static void deleteArray_TConfidenceLevel(void *p);
   static void destruct_TConfidenceLevel(void *p);

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

namespace ROOT {
   void TGraphAsymmErrors_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGraphAsymmErrors(void *p = 0);
   static void *newArray_TGraphAsymmErrors(Long_t size, void *p);
   static void delete_TGraphAsymmErrors(void *p);
   static void deleteArray_TGraphAsymmErrors(void *p);
   static void destruct_TGraphAsymmErrors(void *p);
   static void streamer_TGraphAsymmErrors(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGraphAsymmErrors*)
   {
      ::TGraphAsymmErrors *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGraphAsymmErrors >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGraphAsymmErrors", ::TGraphAsymmErrors::Class_Version(), "include/TGraphAsymmErrors.h", 28,
                  typeid(::TGraphAsymmErrors), DefineBehavior(ptr, ptr),
                  &::TGraphAsymmErrors::Dictionary, isa_proxy, 1,
                  sizeof(::TGraphAsymmErrors) );
      instance.SetNew(&new_TGraphAsymmErrors);
      instance.SetNewArray(&newArray_TGraphAsymmErrors);
      instance.SetDelete(&delete_TGraphAsymmErrors);
      instance.SetDeleteArray(&deleteArray_TGraphAsymmErrors);
      instance.SetDestructor(&destruct_TGraphAsymmErrors);
      instance.SetStreamerFunc(&streamer_TGraphAsymmErrors);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGraphAsymmErrors*)
   {
      return GenerateInitInstanceLocal((::TGraphAsymmErrors*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGraphAsymmErrors*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TH2_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TH2(void *p);
   static void deleteArray_TH2(void *p);
   static void destruct_TH2(void *p);
   static void directoryAutoAdd_TH2(void *p, TDirectory *dir);
   static void streamer_TH2(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TH2*)
   {
      ::TH2 *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TH2 >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TH2", ::TH2::Class_Version(), "include/TH2.h", 36,
                  typeid(::TH2), DefineBehavior(ptr, ptr),
                  &::TH2::Dictionary, isa_proxy, 1,
                  sizeof(::TH2) );
      instance.SetDelete(&delete_TH2);
      instance.SetDeleteArray(&deleteArray_TH2);
      instance.SetDestructor(&destruct_TH2);
      instance.SetDirectoryAutoAdd(&directoryAutoAdd_TH2);
      instance.SetStreamerFunc(&streamer_TH2);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TH2*)
   {
      return GenerateInitInstanceLocal((::TH2*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TH2*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TEfficiency_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEfficiency(void *p = 0);
   static void *newArray_TEfficiency(Long_t size, void *p);
   static void delete_TEfficiency(void *p);
   static void deleteArray_TEfficiency(void *p);
   static void destruct_TEfficiency(void *p);

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

namespace ROOT {
   void TFormulaPrimitive_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TFormulaPrimitive(void *p = 0);
   static void *newArray_TFormulaPrimitive(Long_t size, void *p);
   static void delete_TFormulaPrimitive(void *p);
   static void deleteArray_TFormulaPrimitive(void *p);
   static void destruct_TFormulaPrimitive(void *p);

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

namespace ROOT {
   void TFormula_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TFormula(void *p = 0);
   static void *newArray_TFormula(Long_t size, void *p);
   static void delete_TFormula(void *p);
   static void deleteArray_TFormula(void *p);
   static void destruct_TFormula(void *p);
   static void streamer_TFormula(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TFormula*)
   {
      ::TFormula *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TFormula >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TFormula", ::TFormula::Class_Version(), "include/TFormula.h", 65,
                  typeid(::TFormula), DefineBehavior(ptr, ptr),
                  &::TFormula::Dictionary, isa_proxy, 1,
                  sizeof(::TFormula) );
      instance.SetNew(&new_TFormula);
      instance.SetNewArray(&newArray_TFormula);
      instance.SetDelete(&delete_TFormula);
      instance.SetDeleteArray(&deleteArray_TFormula);
      instance.SetDestructor(&destruct_TFormula);
      instance.SetStreamerFunc(&streamer_TFormula);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TFormula*)
   {
      return GenerateInitInstanceLocal((::TFormula*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TFormula*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TF12_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TF12(void *p = 0);
   static void *newArray_TF12(Long_t size, void *p);
   static void delete_TF12(void *p);
   static void deleteArray_TF12(void *p);
   static void destruct_TF12(void *p);

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

namespace ROOT {
   void TF3_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TF3(void *p = 0);
   static void *newArray_TF3(Long_t size, void *p);
   static void delete_TF3(void *p);
   static void deleteArray_TF3(void *p);
   static void destruct_TF3(void *p);
   static void streamer_TF3(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TF3*)
   {
      ::TF3 *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TF3 >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TF3", ::TF3::Class_Version(), "include/TF3.h", 30,
                  typeid(::TF3), DefineBehavior(ptr, ptr),
                  &::TF3::Dictionary, isa_proxy, 1,
                  sizeof(::TF3) );
      instance.SetNew(&new_TF3);
      instance.SetNewArray(&newArray_TF3);
      instance.SetDelete(&delete_TF3);
      instance.SetDeleteArray(&deleteArray_TF3);
      instance.SetDestructor(&destruct_TF3);
      instance.SetStreamerFunc(&streamer_TF3);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TF3*)
   {
      return GenerateInitInstanceLocal((::TF3*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TF3*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TFractionFitter_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TFractionFitter(void *p = 0);
   static void *newArray_TFractionFitter(Long_t size, void *p);
   static void delete_TFractionFitter(void *p);
   static void deleteArray_TFractionFitter(void *p);
   static void destruct_TFractionFitter(void *p);

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

namespace ROOT {
   void TVirtualHistPainter_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TVirtualHistPainter(void *p);
   static void deleteArray_TVirtualHistPainter(void *p);
   static void destruct_TVirtualHistPainter(void *p);

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

namespace ROOT {
   void TH2D_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TH2D(void *p = 0);
   static void *newArray_TH2D(Long_t size, void *p);
   static void delete_TH2D(void *p);
   static void deleteArray_TH2D(void *p);
   static void destruct_TH2D(void *p);
   static void directoryAutoAdd_TH2D(void *p, TDirectory *dir);
   static void streamer_TH2D(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TH2D*)
   {
      ::TH2D *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TH2D >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TH2D", ::TH2D::Class_Version(), "include/TH2.h", 290,
                  typeid(::TH2D), DefineBehavior(ptr, ptr),
                  &::TH2D::Dictionary, isa_proxy, 1,
                  sizeof(::TH2D) );
      instance.SetNew(&new_TH2D);
      instance.SetNewArray(&newArray_TH2D);
      instance.SetDelete(&delete_TH2D);
      instance.SetDeleteArray(&deleteArray_TH2D);
      instance.SetDestructor(&destruct_TH2D);
      instance.SetDirectoryAutoAdd(&directoryAutoAdd_TH2D);
      instance.SetStreamerFunc(&streamer_TH2D);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TH2D*)
   {
      return GenerateInitInstanceLocal((::TH2D*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TH2D*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGraph2DErrors_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGraph2DErrors(void *p = 0);
   static void *newArray_TGraph2DErrors(Long_t size, void *p);
   static void delete_TGraph2DErrors(void *p);
   static void deleteArray_TGraph2DErrors(void *p);
   static void destruct_TGraph2DErrors(void *p);
   static void directoryAutoAdd_TGraph2DErrors(void *p, TDirectory *dir);
   static void streamer_TGraph2DErrors(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGraph2DErrors*)
   {
      ::TGraph2DErrors *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGraph2DErrors >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGraph2DErrors", ::TGraph2DErrors::Class_Version(), "include/TGraph2DErrors.h", 28,
                  typeid(::TGraph2DErrors), DefineBehavior(ptr, ptr),
                  &::TGraph2DErrors::Dictionary, isa_proxy, 1,
                  sizeof(::TGraph2DErrors) );
      instance.SetNew(&new_TGraph2DErrors);
      instance.SetNewArray(&newArray_TGraph2DErrors);
      instance.SetDelete(&delete_TGraph2DErrors);
      instance.SetDeleteArray(&deleteArray_TGraph2DErrors);
      instance.SetDestructor(&destruct_TGraph2DErrors);
      instance.SetDirectoryAutoAdd(&directoryAutoAdd_TGraph2DErrors);
      instance.SetStreamerFunc(&streamer_TGraph2DErrors);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGraph2DErrors*)
   {
      return GenerateInitInstanceLocal((::TGraph2DErrors*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGraph2DErrors*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TH1F_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TH1F(void *p = 0);
   static void *newArray_TH1F(Long_t size, void *p);
   static void delete_TH1F(void *p);
   static void deleteArray_TH1F(void *p);
   static void destruct_TH1F(void *p);
   static void directoryAutoAdd_TH1F(void *p, TDirectory *dir);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TH1F*)
   {
      ::TH1F *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TH1F >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TH1F", ::TH1F::Class_Version(), "include/TH1.h", 501,
                  typeid(::TH1F), DefineBehavior(ptr, ptr),
                  &::TH1F::Dictionary, isa_proxy, 4,
                  sizeof(::TH1F) );
      instance.SetNew(&new_TH1F);
      instance.SetNewArray(&newArray_TH1F);
      instance.SetDelete(&delete_TH1F);
      instance.SetDeleteArray(&deleteArray_TH1F);
      instance.SetDestructor(&destruct_TH1F);
      instance.SetDirectoryAutoAdd(&directoryAutoAdd_TH1F);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TH1F*)
   {
      return GenerateInitInstanceLocal((::TH1F*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TH1F*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TSpline_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TSpline(void *p);
   static void deleteArray_TSpline(void *p);
   static void destruct_TSpline(void *p);
   static void streamer_TSpline(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGraphBentErrors_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGraphBentErrors(void *p = 0);
   static void *newArray_TGraphBentErrors(Long_t size, void *p);
   static void delete_TGraphBentErrors(void *p);
   static void deleteArray_TGraphBentErrors(void *p);
   static void destruct_TGraphBentErrors(void *p);

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

namespace ROOT {
   void TGraphDelaunay_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGraphDelaunay(void *p = 0);
   static void *newArray_TGraphDelaunay(Long_t size, void *p);
   static void delete_TGraphDelaunay(void *p);
   static void deleteArray_TGraphDelaunay(void *p);
   static void destruct_TGraphDelaunay(void *p);

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

namespace ROOT {
   void TGraphSmooth_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGraphSmooth(void *p = 0);
   static void *newArray_TGraphSmooth(Long_t size, void *p);
   static void delete_TGraphSmooth(void *p);
   static void deleteArray_TGraphSmooth(void *p);
   static void destruct_TGraphSmooth(void *p);

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

namespace ROOT {
   void TGraphTime_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGraphTime(void *p = 0);
   static void *newArray_TGraphTime(Long_t size, void *p);
   static void delete_TGraphTime(void *p);
   static void deleteArray_TGraphTime(void *p);
   static void destruct_TGraphTime(void *p);

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

namespace ROOT {
   void TH1D_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TH1D(void *p = 0);
   static void *newArray_TH1D(Long_t size, void *p);
   static void delete_TH1D(void *p);
   static void deleteArray_TH1D(void *p);
   static void destruct_TH1D(void *p);
   static void directoryAutoAdd_TH1D(void *p, TDirectory *dir);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TH1D*)
   {
      ::TH1D *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TH1D >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TH1D", ::TH1D::Class_Version(), "include/TH1.h", 546,
                  typeid(::TH1D), DefineBehavior(ptr, ptr),
                  &::TH1D::Dictionary, isa_proxy, 4,
                  sizeof(::TH1D) );
      instance.SetNew(&new_TH1D);
      instance.SetNewArray(&newArray_TH1D);
      instance.SetDelete(&delete_TH1D);
      instance.SetDeleteArray(&deleteArray_TH1D);
      instance.SetDestructor(&destruct_TH1D);
      instance.SetDirectoryAutoAdd(&directoryAutoAdd_TH1D);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TH1D*)
   {
      return GenerateInitInstanceLocal((::TH1D*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TH1D*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TH1C_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TH1C(void *p = 0);
   static void *newArray_TH1C(Long_t size, void *p);
   static void delete_TH1C(void *p);
   static void deleteArray_TH1C(void *p);
   static void destruct_TH1C(void *p);
   static void directoryAutoAdd_TH1C(void *p, TDirectory *dir);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TH1C*)
   {
      ::TH1C *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TH1C >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TH1C", ::TH1C::Class_Version(), "include/TH1.h", 372,
                  typeid(::TH1C), DefineBehavior(ptr, ptr),
                  &::TH1C::Dictionary, isa_proxy, 4,
                  sizeof(::TH1C) );
      instance.SetNew(&new_TH1C);
      instance.SetNewArray(&newArray_TH1C);
      instance.SetDelete(&delete_TH1C);
      instance.SetDeleteArray(&deleteArray_TH1C);
      instance.SetDestructor(&destruct_TH1C);
      instance.SetDirectoryAutoAdd(&directoryAutoAdd_TH1C);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TH1C*)
   {
      return GenerateInitInstanceLocal((::TH1C*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TH1C*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TH1S_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TH1S(void *p = 0);
   static void *newArray_TH1S(Long_t size, void *p);
   static void delete_TH1S(void *p);
   static void deleteArray_TH1S(void *p);
   static void destruct_TH1S(void *p);
   static void directoryAutoAdd_TH1S(void *p, TDirectory *dir);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TH1S*)
   {
      ::TH1S *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TH1S >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TH1S", ::TH1S::Class_Version(), "include/TH1.h", 415,
                  typeid(::TH1S), DefineBehavior(ptr, ptr),
                  &::TH1S::Dictionary, isa_proxy, 4,
                  sizeof(::TH1S) );
      instance.SetNew(&new_TH1S);
      instance.SetNewArray(&newArray_TH1S);
      instance.SetDelete(&delete_TH1S);
      instance.SetDeleteArray(&deleteArray_TH1S);
      instance.SetDestructor(&destruct_TH1S);
      instance.SetDirectoryAutoAdd(&directoryAutoAdd_TH1S);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TH1S*)
   {
      return GenerateInitInstanceLocal((::TH1S*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TH1S*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TH1I_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TH1I(void *p = 0);
   static void *newArray_TH1I(Long_t size, void *p);
   static void delete_TH1I(void *p);
   static void deleteArray_TH1I(void *p);
   static void destruct_TH1I(void *p);
   static void directoryAutoAdd_TH1I(void *p, TDirectory *dir);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TH1I*)
   {
      ::TH1I *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TH1I >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TH1I", ::TH1I::Class_Version(), "include/TH1.h", 458,
                  typeid(::TH1I), DefineBehavior(ptr, ptr),
                  &::TH1I::Dictionary, isa_proxy, 4,
                  sizeof(::TH1I) );
      instance.SetNew(&new_TH1I);
      instance.SetNewArray(&newArray_TH1I);
      instance.SetDelete(&delete_TH1I);
      instance.SetDeleteArray(&deleteArray_TH1I);
      instance.SetDestructor(&destruct_TH1I);
      instance.SetDirectoryAutoAdd(&directoryAutoAdd_TH1I);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TH1I*)
   {
      return GenerateInitInstanceLocal((::TH1I*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TH1I*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TH1K_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TH1K(void *p = 0);
   static void *newArray_TH1K(Long_t size, void *p);
   static void delete_TH1K(void *p);
   static void deleteArray_TH1K(void *p);
   static void destruct_TH1K(void *p);
   static void directoryAutoAdd_TH1K(void *p, TDirectory *dir);

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

namespace ROOT {
   void TProfile_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TProfile(void *p = 0);
   static void *newArray_TProfile(Long_t size, void *p);
   static void delete_TProfile(void *p);
   static void deleteArray_TProfile(void *p);
   static void destruct_TProfile(void *p);
   static void directoryAutoAdd_TProfile(void *p, TDirectory *dir);
   static void streamer_TProfile(TBuffer &buf, void *obj);

   // Schema evolution read functions
   static void read_TProfile_0( char* target, TVirtualObject *oldObj )
   {
      //--- Automatically generated variables ---
      static TClassRef cls("TProfile");
      static Long_t offset_fBinSumw2 = cls->GetDataMemberOffset("fBinSumw2");
      TArrayD& fBinSumw2 = *(TArrayD*)(target+offset_fBinSumw2);
      TProfile* newObj = (TProfile*)target;
      // Supress warning message.
      if (oldObj) {}

      if (newObj) {}

      //--- User's code ---
      fBinSumw2.Reset(); 
   }

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TProfile*)
   {
      ::TProfile *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TProfile >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TProfile", ::TProfile::Class_Version(), "include/TProfile.h", 34,
                  typeid(::TProfile), DefineBehavior(ptr, ptr),
                  &::TProfile::Dictionary, isa_proxy, 1,
                  sizeof(::TProfile) );
      instance.SetNew(&new_TProfile);
      instance.SetNewArray(&newArray_TProfile);
      instance.SetDelete(&delete_TProfile);
      instance.SetDeleteArray(&deleteArray_TProfile);
      instance.SetDestructor(&destruct_TProfile);
      instance.SetDirectoryAutoAdd(&directoryAutoAdd_TProfile);
      instance.SetStreamerFunc(&streamer_TProfile);

      ROOT::TSchemaHelper* rule;

      // the io read rules
      std::vector<ROOT::TSchemaHelper> readrules(1);
      rule = &readrules[0];
      rule->fSourceClass = "TProfile";
      rule->fTarget      = "fBinSumw2";
      rule->fSource      = "";
      rule->fFunctionPtr = (void *)G__func2void( read_TProfile_0);
      rule->fCode        = " fBinSumw2.Reset(); ";
      rule->fVersion     = "[1-5]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TProfile*)
   {
      return GenerateInitInstanceLocal((::TProfile*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TProfile*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TH2C_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TH2C(void *p = 0);
   static void *newArray_TH2C(Long_t size, void *p);
   static void delete_TH2C(void *p);
   static void deleteArray_TH2C(void *p);
   static void destruct_TH2C(void *p);
   static void directoryAutoAdd_TH2C(void *p, TDirectory *dir);
   static void streamer_TH2C(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TH2C*)
   {
      ::TH2C *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TH2C >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TH2C", ::TH2C::Class_Version(), "include/TH2.h", 120,
                  typeid(::TH2C), DefineBehavior(ptr, ptr),
                  &::TH2C::Dictionary, isa_proxy, 1,
                  sizeof(::TH2C) );
      instance.SetNew(&new_TH2C);
      instance.SetNewArray(&newArray_TH2C);
      instance.SetDelete(&delete_TH2C);
      instance.SetDeleteArray(&deleteArray_TH2C);
      instance.SetDestructor(&destruct_TH2C);
      instance.SetDirectoryAutoAdd(&directoryAutoAdd_TH2C);
      instance.SetStreamerFunc(&streamer_TH2C);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TH2C*)
   {
      return GenerateInitInstanceLocal((::TH2C*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TH2C*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TH2S_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TH2S(void *p = 0);
   static void *newArray_TH2S(Long_t size, void *p);
   static void delete_TH2S(void *p);
   static void deleteArray_TH2S(void *p);
   static void destruct_TH2S(void *p);
   static void directoryAutoAdd_TH2S(void *p, TDirectory *dir);
   static void streamer_TH2S(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TH2S*)
   {
      ::TH2S *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TH2S >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TH2S", ::TH2S::Class_Version(), "include/TH2.h", 162,
                  typeid(::TH2S), DefineBehavior(ptr, ptr),
                  &::TH2S::Dictionary, isa_proxy, 1,
                  sizeof(::TH2S) );
      instance.SetNew(&new_TH2S);
      instance.SetNewArray(&newArray_TH2S);
      instance.SetDelete(&delete_TH2S);
      instance.SetDeleteArray(&deleteArray_TH2S);
      instance.SetDestructor(&destruct_TH2S);
      instance.SetDirectoryAutoAdd(&directoryAutoAdd_TH2S);
      instance.SetStreamerFunc(&streamer_TH2S);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TH2S*)
   {
      return GenerateInitInstanceLocal((::TH2S*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TH2S*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TH2I_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TH2I(void *p = 0);
   static void *newArray_TH2I(Long_t size, void *p);
   static void delete_TH2I(void *p);
   static void deleteArray_TH2I(void *p);
   static void destruct_TH2I(void *p);
   static void directoryAutoAdd_TH2I(void *p, TDirectory *dir);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TH2I*)
   {
      ::TH2I *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TH2I >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TH2I", ::TH2I::Class_Version(), "include/TH2.h", 204,
                  typeid(::TH2I), DefineBehavior(ptr, ptr),
                  &::TH2I::Dictionary, isa_proxy, 4,
                  sizeof(::TH2I) );
      instance.SetNew(&new_TH2I);
      instance.SetNewArray(&newArray_TH2I);
      instance.SetDelete(&delete_TH2I);
      instance.SetDeleteArray(&deleteArray_TH2I);
      instance.SetDestructor(&destruct_TH2I);
      instance.SetDirectoryAutoAdd(&directoryAutoAdd_TH2I);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TH2I*)
   {
      return GenerateInitInstanceLocal((::TH2I*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TH2I*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TH2F_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TH2F(void *p = 0);
   static void *newArray_TH2F(Long_t size, void *p);
   static void delete_TH2F(void *p);
   static void deleteArray_TH2F(void *p);
   static void destruct_TH2F(void *p);
   static void directoryAutoAdd_TH2F(void *p, TDirectory *dir);
   static void streamer_TH2F(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TH2F*)
   {
      ::TH2F *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TH2F >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TH2F", ::TH2F::Class_Version(), "include/TH2.h", 246,
                  typeid(::TH2F), DefineBehavior(ptr, ptr),
                  &::TH2F::Dictionary, isa_proxy, 1,
                  sizeof(::TH2F) );
      instance.SetNew(&new_TH2F);
      instance.SetNewArray(&newArray_TH2F);
      instance.SetDelete(&delete_TH2F);
      instance.SetDeleteArray(&deleteArray_TH2F);
      instance.SetDestructor(&destruct_TH2F);
      instance.SetDirectoryAutoAdd(&directoryAutoAdd_TH2F);
      instance.SetStreamerFunc(&streamer_TH2F);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TH2F*)
   {
      return GenerateInitInstanceLocal((::TH2F*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TH2F*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TH2PolyBin_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TH2PolyBin(void *p = 0);
   static void *newArray_TH2PolyBin(Long_t size, void *p);
   static void delete_TH2PolyBin(void *p);
   static void deleteArray_TH2PolyBin(void *p);
   static void destruct_TH2PolyBin(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TH2PolyBin*)
   {
      ::TH2PolyBin *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TH2PolyBin >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TH2PolyBin", ::TH2PolyBin::Class_Version(), "include/TH2Poly.h", 29,
                  typeid(::TH2PolyBin), DefineBehavior(ptr, ptr),
                  &::TH2PolyBin::Dictionary, isa_proxy, 4,
                  sizeof(::TH2PolyBin) );
      instance.SetNew(&new_TH2PolyBin);
      instance.SetNewArray(&newArray_TH2PolyBin);
      instance.SetDelete(&delete_TH2PolyBin);
      instance.SetDeleteArray(&deleteArray_TH2PolyBin);
      instance.SetDestructor(&destruct_TH2PolyBin);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TH2PolyBin*)
   {
      return GenerateInitInstanceLocal((::TH2PolyBin*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TH2PolyBin*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TH2Poly_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TH2Poly(void *p = 0);
   static void *newArray_TH2Poly(Long_t size, void *p);
   static void delete_TH2Poly(void *p);
   static void deleteArray_TH2Poly(void *p);
   static void destruct_TH2Poly(void *p);
   static void directoryAutoAdd_TH2Poly(void *p, TDirectory *dir);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TH2Poly*)
   {
      ::TH2Poly *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TH2Poly >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TH2Poly", ::TH2Poly::Class_Version(), "include/TH2Poly.h", 70,
                  typeid(::TH2Poly), DefineBehavior(ptr, ptr),
                  &::TH2Poly::Dictionary, isa_proxy, 4,
                  sizeof(::TH2Poly) );
      instance.SetNew(&new_TH2Poly);
      instance.SetNewArray(&newArray_TH2Poly);
      instance.SetDelete(&delete_TH2Poly);
      instance.SetDeleteArray(&deleteArray_TH2Poly);
      instance.SetDestructor(&destruct_TH2Poly);
      instance.SetDirectoryAutoAdd(&directoryAutoAdd_TH2Poly);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TH2Poly*)
   {
      return GenerateInitInstanceLocal((::TH2Poly*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TH2Poly*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TProfile2D_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TProfile2D(void *p = 0);
   static void *newArray_TProfile2D(Long_t size, void *p);
   static void delete_TProfile2D(void *p);
   static void deleteArray_TProfile2D(void *p);
   static void destruct_TProfile2D(void *p);
   static void directoryAutoAdd_TProfile2D(void *p, TDirectory *dir);
   static void streamer_TProfile2D(TBuffer &buf, void *obj);

   // Schema evolution read functions
   static void read_TProfile2D_0( char* target, TVirtualObject *oldObj )
   {
      //--- Automatically generated variables ---
      static TClassRef cls("TProfile2D");
      static Long_t offset_fBinSumw2 = cls->GetDataMemberOffset("fBinSumw2");
      TArrayD& fBinSumw2 = *(TArrayD*)(target+offset_fBinSumw2);
      TProfile2D* newObj = (TProfile2D*)target;
      // Supress warning message.
      if (oldObj) {}

      if (newObj) {}

      //--- User's code ---
      fBinSumw2.Reset(); 
   }

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TProfile2D*)
   {
      ::TProfile2D *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TProfile2D >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TProfile2D", ::TProfile2D::Class_Version(), "include/TProfile2D.h", 31,
                  typeid(::TProfile2D), DefineBehavior(ptr, ptr),
                  &::TProfile2D::Dictionary, isa_proxy, 1,
                  sizeof(::TProfile2D) );
      instance.SetNew(&new_TProfile2D);
      instance.SetNewArray(&newArray_TProfile2D);
      instance.SetDelete(&delete_TProfile2D);
      instance.SetDeleteArray(&deleteArray_TProfile2D);
      instance.SetDestructor(&destruct_TProfile2D);
      instance.SetDirectoryAutoAdd(&directoryAutoAdd_TProfile2D);
      instance.SetStreamerFunc(&streamer_TProfile2D);

      ROOT::TSchemaHelper* rule;

      // the io read rules
      std::vector<ROOT::TSchemaHelper> readrules(1);
      rule = &readrules[0];
      rule->fSourceClass = "TProfile2D";
      rule->fTarget      = "fBinSumw2";
      rule->fSource      = "";
      rule->fFunctionPtr = (void *)G__func2void( read_TProfile2D_0);
      rule->fCode        = " fBinSumw2.Reset(); ";
      rule->fVersion     = "[1-6]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TProfile2D*)
   {
      return GenerateInitInstanceLocal((::TProfile2D*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TProfile2D*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TH3_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TH3(void *p);
   static void deleteArray_TH3(void *p);
   static void destruct_TH3(void *p);
   static void directoryAutoAdd_TH3(void *p, TDirectory *dir);
   static void streamer_TH3(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TH3*)
   {
      ::TH3 *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TH3 >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TH3", ::TH3::Class_Version(), "include/TH3.h", 35,
                  typeid(::TH3), DefineBehavior(ptr, ptr),
                  &::TH3::Dictionary, isa_proxy, 1,
                  sizeof(::TH3) );
      instance.SetDelete(&delete_TH3);
      instance.SetDeleteArray(&deleteArray_TH3);
      instance.SetDestructor(&destruct_TH3);
      instance.SetDirectoryAutoAdd(&directoryAutoAdd_TH3);
      instance.SetStreamerFunc(&streamer_TH3);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TH3*)
   {
      return GenerateInitInstanceLocal((::TH3*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TH3*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TH3C_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TH3C(void *p = 0);
   static void *newArray_TH3C(Long_t size, void *p);
   static void delete_TH3C(void *p);
   static void deleteArray_TH3C(void *p);
   static void destruct_TH3C(void *p);
   static void directoryAutoAdd_TH3C(void *p, TDirectory *dir);
   static void streamer_TH3C(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TH3C*)
   {
      ::TH3C *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TH3C >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TH3C", ::TH3C::Class_Version(), "include/TH3.h", 131,
                  typeid(::TH3C), DefineBehavior(ptr, ptr),
                  &::TH3C::Dictionary, isa_proxy, 1,
                  sizeof(::TH3C) );
      instance.SetNew(&new_TH3C);
      instance.SetNewArray(&newArray_TH3C);
      instance.SetDelete(&delete_TH3C);
      instance.SetDeleteArray(&deleteArray_TH3C);
      instance.SetDestructor(&destruct_TH3C);
      instance.SetDirectoryAutoAdd(&directoryAutoAdd_TH3C);
      instance.SetStreamerFunc(&streamer_TH3C);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TH3C*)
   {
      return GenerateInitInstanceLocal((::TH3C*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TH3C*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TH3S_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TH3S(void *p = 0);
   static void *newArray_TH3S(Long_t size, void *p);
   static void delete_TH3S(void *p);
   static void deleteArray_TH3S(void *p);
   static void destruct_TH3S(void *p);
   static void directoryAutoAdd_TH3S(void *p, TDirectory *dir);
   static void streamer_TH3S(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TH3S*)
   {
      ::TH3S *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TH3S >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TH3S", ::TH3S::Class_Version(), "include/TH3.h", 170,
                  typeid(::TH3S), DefineBehavior(ptr, ptr),
                  &::TH3S::Dictionary, isa_proxy, 1,
                  sizeof(::TH3S) );
      instance.SetNew(&new_TH3S);
      instance.SetNewArray(&newArray_TH3S);
      instance.SetDelete(&delete_TH3S);
      instance.SetDeleteArray(&deleteArray_TH3S);
      instance.SetDestructor(&destruct_TH3S);
      instance.SetDirectoryAutoAdd(&directoryAutoAdd_TH3S);
      instance.SetStreamerFunc(&streamer_TH3S);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TH3S*)
   {
      return GenerateInitInstanceLocal((::TH3S*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TH3S*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TH3I_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TH3I(void *p = 0);
   static void *newArray_TH3I(Long_t size, void *p);
   static void delete_TH3I(void *p);
   static void deleteArray_TH3I(void *p);
   static void destruct_TH3I(void *p);
   static void directoryAutoAdd_TH3I(void *p, TDirectory *dir);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TH3I*)
   {
      ::TH3I *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TH3I >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TH3I", ::TH3I::Class_Version(), "include/TH3.h", 209,
                  typeid(::TH3I), DefineBehavior(ptr, ptr),
                  &::TH3I::Dictionary, isa_proxy, 4,
                  sizeof(::TH3I) );
      instance.SetNew(&new_TH3I);
      instance.SetNewArray(&newArray_TH3I);
      instance.SetDelete(&delete_TH3I);
      instance.SetDeleteArray(&deleteArray_TH3I);
      instance.SetDestructor(&destruct_TH3I);
      instance.SetDirectoryAutoAdd(&directoryAutoAdd_TH3I);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TH3I*)
   {
      return GenerateInitInstanceLocal((::TH3I*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TH3I*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TH3F_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TH3F(void *p = 0);
   static void *newArray_TH3F(Long_t size, void *p);
   static void delete_TH3F(void *p);
   static void deleteArray_TH3F(void *p);
   static void destruct_TH3F(void *p);
   static void directoryAutoAdd_TH3F(void *p, TDirectory *dir);
   static void streamer_TH3F(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TH3F*)
   {
      ::TH3F *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TH3F >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TH3F", ::TH3F::Class_Version(), "include/TH3.h", 249,
                  typeid(::TH3F), DefineBehavior(ptr, ptr),
                  &::TH3F::Dictionary, isa_proxy, 1,
                  sizeof(::TH3F) );
      instance.SetNew(&new_TH3F);
      instance.SetNewArray(&newArray_TH3F);
      instance.SetDelete(&delete_TH3F);
      instance.SetDeleteArray(&deleteArray_TH3F);
      instance.SetDestructor(&destruct_TH3F);
      instance.SetDirectoryAutoAdd(&directoryAutoAdd_TH3F);
      instance.SetStreamerFunc(&streamer_TH3F);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TH3F*)
   {
      return GenerateInitInstanceLocal((::TH3F*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TH3F*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TH3D_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TH3D(void *p = 0);
   static void *newArray_TH3D(Long_t size, void *p);
   static void delete_TH3D(void *p);
   static void deleteArray_TH3D(void *p);
   static void destruct_TH3D(void *p);
   static void directoryAutoAdd_TH3D(void *p, TDirectory *dir);
   static void streamer_TH3D(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TH3D*)
   {
      ::TH3D *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TH3D >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TH3D", ::TH3D::Class_Version(), "include/TH3.h", 289,
                  typeid(::TH3D), DefineBehavior(ptr, ptr),
                  &::TH3D::Dictionary, isa_proxy, 1,
                  sizeof(::TH3D) );
      instance.SetNew(&new_TH3D);
      instance.SetNewArray(&newArray_TH3D);
      instance.SetDelete(&delete_TH3D);
      instance.SetDeleteArray(&deleteArray_TH3D);
      instance.SetDestructor(&destruct_TH3D);
      instance.SetDirectoryAutoAdd(&directoryAutoAdd_TH3D);
      instance.SetStreamerFunc(&streamer_TH3D);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TH3D*)
   {
      return GenerateInitInstanceLocal((::TH3D*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TH3D*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void THLimitsFinder_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_THLimitsFinder(void *p = 0);
   static void *newArray_THLimitsFinder(Long_t size, void *p);
   static void delete_THLimitsFinder(void *p);
   static void deleteArray_THLimitsFinder(void *p);
   static void destruct_THLimitsFinder(void *p);

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

namespace ROOT {
   void THnSparseArrayChunk_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_THnSparseArrayChunk(void *p = 0);
   static void *newArray_THnSparseArrayChunk(Long_t size, void *p);
   static void delete_THnSparseArrayChunk(void *p);
   static void deleteArray_THnSparseArrayChunk(void *p);
   static void destruct_THnSparseArrayChunk(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::THnSparseArrayChunk*)
   {
      ::THnSparseArrayChunk *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::THnSparseArrayChunk >(0);
      static ::ROOT::TGenericClassInfo 
         instance("THnSparseArrayChunk", ::THnSparseArrayChunk::Class_Version(), "include/THnSparse.h", 64,
                  typeid(::THnSparseArrayChunk), DefineBehavior(ptr, ptr),
                  &::THnSparseArrayChunk::Dictionary, isa_proxy, 4,
                  sizeof(::THnSparseArrayChunk) );
      instance.SetNew(&new_THnSparseArrayChunk);
      instance.SetNewArray(&newArray_THnSparseArrayChunk);
      instance.SetDelete(&delete_THnSparseArrayChunk);
      instance.SetDeleteArray(&deleteArray_THnSparseArrayChunk);
      instance.SetDestructor(&destruct_THnSparseArrayChunk);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::THnSparseArrayChunk*)
   {
      return GenerateInitInstanceLocal((::THnSparseArrayChunk*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::THnSparseArrayChunk*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void THnSparseTlETArrayDgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void THnSparseTlETArrayDgR_Dictionary();
   static void *new_THnSparseTlETArrayDgR(void *p = 0);
   static void *newArray_THnSparseTlETArrayDgR(Long_t size, void *p);
   static void delete_THnSparseTlETArrayDgR(void *p);
   static void deleteArray_THnSparseTlETArrayDgR(void *p);
   static void destruct_THnSparseTlETArrayDgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::THnSparseT<TArrayD>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::THnSparseT<TArrayD>) == sizeof(::ROOT::Shadow::THnSparseTlETArrayDgR));
      ::THnSparseT<TArrayD> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::THnSparseT<TArrayD> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("THnSparseT<TArrayD>", ::THnSparseT<TArrayD>::Class_Version(), "include/THnSparse.h", 308,
                  typeid(::THnSparseT<TArrayD>), DefineBehavior(ptr, ptr),
                  &THnSparseTlETArrayDgR_Dictionary, isa_proxy, 4,
                  sizeof(::THnSparseT<TArrayD>) );
      instance.SetNew(&new_THnSparseTlETArrayDgR);
      instance.SetNewArray(&newArray_THnSparseTlETArrayDgR);
      instance.SetDelete(&delete_THnSparseTlETArrayDgR);
      instance.SetDeleteArray(&deleteArray_THnSparseTlETArrayDgR);
      instance.SetDestructor(&destruct_THnSparseTlETArrayDgR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::THnSparseT<TArrayD>*)
   {
      return GenerateInitInstanceLocal((::THnSparseT<TArrayD>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::THnSparseT<TArrayD>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   void THnSparseTlETArrayFgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void THnSparseTlETArrayFgR_Dictionary();
   static void *new_THnSparseTlETArrayFgR(void *p = 0);
   static void *newArray_THnSparseTlETArrayFgR(Long_t size, void *p);
   static void delete_THnSparseTlETArrayFgR(void *p);
   static void deleteArray_THnSparseTlETArrayFgR(void *p);
   static void destruct_THnSparseTlETArrayFgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::THnSparseT<TArrayF>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::THnSparseT<TArrayF>) == sizeof(::ROOT::Shadow::THnSparseTlETArrayFgR));
      ::THnSparseT<TArrayF> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::THnSparseT<TArrayF> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("THnSparseT<TArrayF>", ::THnSparseT<TArrayF>::Class_Version(), "include/THnSparse.h", 308,
                  typeid(::THnSparseT<TArrayF>), DefineBehavior(ptr, ptr),
                  &THnSparseTlETArrayFgR_Dictionary, isa_proxy, 4,
                  sizeof(::THnSparseT<TArrayF>) );
      instance.SetNew(&new_THnSparseTlETArrayFgR);
      instance.SetNewArray(&newArray_THnSparseTlETArrayFgR);
      instance.SetDelete(&delete_THnSparseTlETArrayFgR);
      instance.SetDeleteArray(&deleteArray_THnSparseTlETArrayFgR);
      instance.SetDestructor(&destruct_THnSparseTlETArrayFgR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::THnSparseT<TArrayF>*)
   {
      return GenerateInitInstanceLocal((::THnSparseT<TArrayF>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::THnSparseT<TArrayF>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   void THnSparseTlETArrayLgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void THnSparseTlETArrayLgR_Dictionary();
   static void *new_THnSparseTlETArrayLgR(void *p = 0);
   static void *newArray_THnSparseTlETArrayLgR(Long_t size, void *p);
   static void delete_THnSparseTlETArrayLgR(void *p);
   static void deleteArray_THnSparseTlETArrayLgR(void *p);
   static void destruct_THnSparseTlETArrayLgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::THnSparseT<TArrayL>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::THnSparseT<TArrayL>) == sizeof(::ROOT::Shadow::THnSparseTlETArrayLgR));
      ::THnSparseT<TArrayL> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::THnSparseT<TArrayL> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("THnSparseT<TArrayL>", ::THnSparseT<TArrayL>::Class_Version(), "include/THnSparse.h", 308,
                  typeid(::THnSparseT<TArrayL>), DefineBehavior(ptr, ptr),
                  &THnSparseTlETArrayLgR_Dictionary, isa_proxy, 4,
                  sizeof(::THnSparseT<TArrayL>) );
      instance.SetNew(&new_THnSparseTlETArrayLgR);
      instance.SetNewArray(&newArray_THnSparseTlETArrayLgR);
      instance.SetDelete(&delete_THnSparseTlETArrayLgR);
      instance.SetDeleteArray(&deleteArray_THnSparseTlETArrayLgR);
      instance.SetDestructor(&destruct_THnSparseTlETArrayLgR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::THnSparseT<TArrayL>*)
   {
      return GenerateInitInstanceLocal((::THnSparseT<TArrayL>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::THnSparseT<TArrayL>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   void THnSparseTlETArrayIgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void THnSparseTlETArrayIgR_Dictionary();
   static void *new_THnSparseTlETArrayIgR(void *p = 0);
   static void *newArray_THnSparseTlETArrayIgR(Long_t size, void *p);
   static void delete_THnSparseTlETArrayIgR(void *p);
   static void deleteArray_THnSparseTlETArrayIgR(void *p);
   static void destruct_THnSparseTlETArrayIgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::THnSparseT<TArrayI>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::THnSparseT<TArrayI>) == sizeof(::ROOT::Shadow::THnSparseTlETArrayIgR));
      ::THnSparseT<TArrayI> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::THnSparseT<TArrayI> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("THnSparseT<TArrayI>", ::THnSparseT<TArrayI>::Class_Version(), "include/THnSparse.h", 308,
                  typeid(::THnSparseT<TArrayI>), DefineBehavior(ptr, ptr),
                  &THnSparseTlETArrayIgR_Dictionary, isa_proxy, 4,
                  sizeof(::THnSparseT<TArrayI>) );
      instance.SetNew(&new_THnSparseTlETArrayIgR);
      instance.SetNewArray(&newArray_THnSparseTlETArrayIgR);
      instance.SetDelete(&delete_THnSparseTlETArrayIgR);
      instance.SetDeleteArray(&deleteArray_THnSparseTlETArrayIgR);
      instance.SetDestructor(&destruct_THnSparseTlETArrayIgR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::THnSparseT<TArrayI>*)
   {
      return GenerateInitInstanceLocal((::THnSparseT<TArrayI>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::THnSparseT<TArrayI>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   void THnSparseTlETArraySgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void THnSparseTlETArraySgR_Dictionary();
   static void *new_THnSparseTlETArraySgR(void *p = 0);
   static void *newArray_THnSparseTlETArraySgR(Long_t size, void *p);
   static void delete_THnSparseTlETArraySgR(void *p);
   static void deleteArray_THnSparseTlETArraySgR(void *p);
   static void destruct_THnSparseTlETArraySgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::THnSparseT<TArrayS>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::THnSparseT<TArrayS>) == sizeof(::ROOT::Shadow::THnSparseTlETArraySgR));
      ::THnSparseT<TArrayS> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::THnSparseT<TArrayS> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("THnSparseT<TArrayS>", ::THnSparseT<TArrayS>::Class_Version(), "include/THnSparse.h", 308,
                  typeid(::THnSparseT<TArrayS>), DefineBehavior(ptr, ptr),
                  &THnSparseTlETArraySgR_Dictionary, isa_proxy, 4,
                  sizeof(::THnSparseT<TArrayS>) );
      instance.SetNew(&new_THnSparseTlETArraySgR);
      instance.SetNewArray(&newArray_THnSparseTlETArraySgR);
      instance.SetDelete(&delete_THnSparseTlETArraySgR);
      instance.SetDeleteArray(&deleteArray_THnSparseTlETArraySgR);
      instance.SetDestructor(&destruct_THnSparseTlETArraySgR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::THnSparseT<TArrayS>*)
   {
      return GenerateInitInstanceLocal((::THnSparseT<TArrayS>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::THnSparseT<TArrayS>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   void THnSparseTlETArrayCgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void THnSparseTlETArrayCgR_Dictionary();
   static void *new_THnSparseTlETArrayCgR(void *p = 0);
   static void *newArray_THnSparseTlETArrayCgR(Long_t size, void *p);
   static void delete_THnSparseTlETArrayCgR(void *p);
   static void deleteArray_THnSparseTlETArrayCgR(void *p);
   static void destruct_THnSparseTlETArrayCgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::THnSparseT<TArrayC>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::THnSparseT<TArrayC>) == sizeof(::ROOT::Shadow::THnSparseTlETArrayCgR));
      ::THnSparseT<TArrayC> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::THnSparseT<TArrayC> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("THnSparseT<TArrayC>", ::THnSparseT<TArrayC>::Class_Version(), "include/THnSparse.h", 308,
                  typeid(::THnSparseT<TArrayC>), DefineBehavior(ptr, ptr),
                  &THnSparseTlETArrayCgR_Dictionary, isa_proxy, 4,
                  sizeof(::THnSparseT<TArrayC>) );
      instance.SetNew(&new_THnSparseTlETArrayCgR);
      instance.SetNewArray(&newArray_THnSparseTlETArrayCgR);
      instance.SetDelete(&delete_THnSparseTlETArrayCgR);
      instance.SetDeleteArray(&deleteArray_THnSparseTlETArrayCgR);
      instance.SetDestructor(&destruct_THnSparseTlETArrayCgR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::THnSparseT<TArrayC>*)
   {
      return GenerateInitInstanceLocal((::THnSparseT<TArrayC>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::THnSparseT<TArrayC>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   void THStack_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_THStack(void *p = 0);
   static void *newArray_THStack(Long_t size, void *p);
   static void delete_THStack(void *p);
   static void deleteArray_THStack(void *p);
   static void destruct_THStack(void *p);

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

namespace ROOT {
   void TKDE_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TKDE(void *p = 0);
   static void *newArray_TKDE(Long_t size, void *p);
   static void delete_TKDE(void *p);
   static void deleteArray_TKDE(void *p);
   static void destruct_TKDE(void *p);

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

namespace ROOT {
   void TLimitDataSource_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TLimitDataSource(void *p = 0);
   static void *newArray_TLimitDataSource(Long_t size, void *p);
   static void delete_TLimitDataSource(void *p);
   static void deleteArray_TLimitDataSource(void *p);
   static void destruct_TLimitDataSource(void *p);

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

namespace ROOT {
   void TLimit_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TLimit(void *p = 0);
   static void *newArray_TLimit(Long_t size, void *p);
   static void delete_TLimit(void *p);
   static void deleteArray_TLimit(void *p);
   static void destruct_TLimit(void *p);

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

namespace ROOT {
   void TMultiDimFit_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMultiDimFit(void *p = 0);
   static void *newArray_TMultiDimFit(Long_t size, void *p);
   static void delete_TMultiDimFit(void *p);
   static void deleteArray_TMultiDimFit(void *p);
   static void destruct_TMultiDimFit(void *p);

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

namespace ROOT {
   void TPolyMarker_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TPolyMarker(void *p = 0);
   static void *newArray_TPolyMarker(Long_t size, void *p);
   static void delete_TPolyMarker(void *p);
   static void deleteArray_TPolyMarker(void *p);
   static void destruct_TPolyMarker(void *p);
   static void streamer_TPolyMarker(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TPolyMarker*)
   {
      ::TPolyMarker *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TPolyMarker >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TPolyMarker", ::TPolyMarker::Class_Version(), "include/TPolyMarker.h", 37,
                  typeid(::TPolyMarker), DefineBehavior(ptr, ptr),
                  &::TPolyMarker::Dictionary, isa_proxy, 1,
                  sizeof(::TPolyMarker) );
      instance.SetNew(&new_TPolyMarker);
      instance.SetNewArray(&newArray_TPolyMarker);
      instance.SetDelete(&delete_TPolyMarker);
      instance.SetDeleteArray(&deleteArray_TPolyMarker);
      instance.SetDestructor(&destruct_TPolyMarker);
      instance.SetStreamerFunc(&streamer_TPolyMarker);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TPolyMarker*)
   {
      return GenerateInitInstanceLocal((::TPolyMarker*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TPolyMarker*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TPrincipal_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TPrincipal(void *p = 0);
   static void *newArray_TPrincipal(Long_t size, void *p);
   static void delete_TPrincipal(void *p);
   static void deleteArray_TPrincipal(void *p);
   static void destruct_TPrincipal(void *p);

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

namespace ROOT {
   void TProfile3D_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TProfile3D(void *p = 0);
   static void *newArray_TProfile3D(Long_t size, void *p);
   static void delete_TProfile3D(void *p);
   static void deleteArray_TProfile3D(void *p);
   static void destruct_TProfile3D(void *p);
   static void directoryAutoAdd_TProfile3D(void *p, TDirectory *dir);

   // Schema evolution read functions
   static void read_TProfile3D_0( char* target, TVirtualObject *oldObj )
   {
      //--- Automatically generated variables ---
      static TClassRef cls("TProfile3D");
      static Long_t offset_fBinSumw2 = cls->GetDataMemberOffset("fBinSumw2");
      TArrayD& fBinSumw2 = *(TArrayD*)(target+offset_fBinSumw2);
      TProfile3D* newObj = (TProfile3D*)target;
      // Supress warning message.
      if (oldObj) {}

      if (newObj) {}

      //--- User's code ---
      fBinSumw2.Reset(); 
   }

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TProfile3D*)
   {
      ::TProfile3D *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TProfile3D >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TProfile3D", ::TProfile3D::Class_Version(), "include/TProfile3D.h", 31,
                  typeid(::TProfile3D), DefineBehavior(ptr, ptr),
                  &::TProfile3D::Dictionary, isa_proxy, 4,
                  sizeof(::TProfile3D) );
      instance.SetNew(&new_TProfile3D);
      instance.SetNewArray(&newArray_TProfile3D);
      instance.SetDelete(&delete_TProfile3D);
      instance.SetDeleteArray(&deleteArray_TProfile3D);
      instance.SetDestructor(&destruct_TProfile3D);
      instance.SetDirectoryAutoAdd(&directoryAutoAdd_TProfile3D);

      ROOT::TSchemaHelper* rule;

      // the io read rules
      std::vector<ROOT::TSchemaHelper> readrules(1);
      rule = &readrules[0];
      rule->fSourceClass = "TProfile3D";
      rule->fTarget      = "fBinSumw2";
      rule->fSource      = "";
      rule->fFunctionPtr = (void *)G__func2void( read_TProfile3D_0);
      rule->fCode        = " fBinSumw2.Reset(); ";
      rule->fVersion     = "[1-6]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TProfile3D*)
   {
      return GenerateInitInstanceLocal((::TProfile3D*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TProfile3D*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TSplinePoly_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TSplinePoly(void *p = 0);
   static void *newArray_TSplinePoly(Long_t size, void *p);
   static void delete_TSplinePoly(void *p);
   static void deleteArray_TSplinePoly(void *p);
   static void destruct_TSplinePoly(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TSplinePoly*)
   {
      ::TSplinePoly *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TSplinePoly >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TSplinePoly", ::TSplinePoly::Class_Version(), "include/TSpline.h", 71,
                  typeid(::TSplinePoly), DefineBehavior(ptr, ptr),
                  &::TSplinePoly::Dictionary, isa_proxy, 4,
                  sizeof(::TSplinePoly) );
      instance.SetNew(&new_TSplinePoly);
      instance.SetNewArray(&newArray_TSplinePoly);
      instance.SetDelete(&delete_TSplinePoly);
      instance.SetDeleteArray(&deleteArray_TSplinePoly);
      instance.SetDestructor(&destruct_TSplinePoly);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TSplinePoly*)
   {
      return GenerateInitInstanceLocal((::TSplinePoly*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TSplinePoly*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TSplinePoly3_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TSplinePoly3(void *p = 0);
   static void *newArray_TSplinePoly3(Long_t size, void *p);
   static void delete_TSplinePoly3(void *p);
   static void deleteArray_TSplinePoly3(void *p);
   static void destruct_TSplinePoly3(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TSplinePoly3*)
   {
      ::TSplinePoly3 *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TSplinePoly3 >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TSplinePoly3", ::TSplinePoly3::Class_Version(), "include/TSpline.h", 106,
                  typeid(::TSplinePoly3), DefineBehavior(ptr, ptr),
                  &::TSplinePoly3::Dictionary, isa_proxy, 4,
                  sizeof(::TSplinePoly3) );
      instance.SetNew(&new_TSplinePoly3);
      instance.SetNewArray(&newArray_TSplinePoly3);
      instance.SetDelete(&delete_TSplinePoly3);
      instance.SetDeleteArray(&deleteArray_TSplinePoly3);
      instance.SetDestructor(&destruct_TSplinePoly3);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TSplinePoly3*)
   {
      return GenerateInitInstanceLocal((::TSplinePoly3*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TSplinePoly3*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TSplinePoly5_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TSplinePoly5(void *p = 0);
   static void *newArray_TSplinePoly5(Long_t size, void *p);
   static void delete_TSplinePoly5(void *p);
   static void deleteArray_TSplinePoly5(void *p);
   static void destruct_TSplinePoly5(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TSplinePoly5*)
   {
      ::TSplinePoly5 *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TSplinePoly5 >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TSplinePoly5", ::TSplinePoly5::Class_Version(), "include/TSpline.h", 147,
                  typeid(::TSplinePoly5), DefineBehavior(ptr, ptr),
                  &::TSplinePoly5::Dictionary, isa_proxy, 4,
                  sizeof(::TSplinePoly5) );
      instance.SetNew(&new_TSplinePoly5);
      instance.SetNewArray(&newArray_TSplinePoly5);
      instance.SetDelete(&delete_TSplinePoly5);
      instance.SetDeleteArray(&deleteArray_TSplinePoly5);
      instance.SetDestructor(&destruct_TSplinePoly5);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TSplinePoly5*)
   {
      return GenerateInitInstanceLocal((::TSplinePoly5*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TSplinePoly5*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TSpline3_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TSpline3(void *p = 0);
   static void *newArray_TSpline3(Long_t size, void *p);
   static void delete_TSpline3(void *p);
   static void deleteArray_TSpline3(void *p);
   static void destruct_TSpline3(void *p);
   static void streamer_TSpline3(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TSpline3*)
   {
      ::TSpline3 *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TSpline3 >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TSpline3", ::TSpline3::Class_Version(), "include/TSpline.h", 194,
                  typeid(::TSpline3), DefineBehavior(ptr, ptr),
                  &::TSpline3::Dictionary, isa_proxy, 1,
                  sizeof(::TSpline3) );
      instance.SetNew(&new_TSpline3);
      instance.SetNewArray(&newArray_TSpline3);
      instance.SetDelete(&delete_TSpline3);
      instance.SetDeleteArray(&deleteArray_TSpline3);
      instance.SetDestructor(&destruct_TSpline3);
      instance.SetStreamerFunc(&streamer_TSpline3);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TSpline3*)
   {
      return GenerateInitInstanceLocal((::TSpline3*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TSpline3*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TSpline5_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TSpline5(void *p = 0);
   static void *newArray_TSpline5(Long_t size, void *p);
   static void delete_TSpline5(void *p);
   static void deleteArray_TSpline5(void *p);
   static void destruct_TSpline5(void *p);
   static void streamer_TSpline5(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TSpline5*)
   {
      ::TSpline5 *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TSpline5 >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TSpline5", ::TSpline5::Class_Version(), "include/TSpline.h", 250,
                  typeid(::TSpline5), DefineBehavior(ptr, ptr),
                  &::TSpline5::Dictionary, isa_proxy, 1,
                  sizeof(::TSpline5) );
      instance.SetNew(&new_TSpline5);
      instance.SetNewArray(&newArray_TSpline5);
      instance.SetDelete(&delete_TSpline5);
      instance.SetDeleteArray(&deleteArray_TSpline5);
      instance.SetDestructor(&destruct_TSpline5);
      instance.SetStreamerFunc(&streamer_TSpline5);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TSpline5*)
   {
      return GenerateInitInstanceLocal((::TSpline5*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TSpline5*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TSVDUnfold_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TSVDUnfold(void *p);
   static void deleteArray_TSVDUnfold(void *p);
   static void destruct_TSVDUnfold(void *p);

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

namespace ROOT {
   void TUnfold_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TUnfold(void *p);
   static void deleteArray_TUnfold(void *p);
   static void destruct_TUnfold(void *p);

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

namespace ROOT {
   void TUnfoldSys_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TUnfoldSys(void *p);
   static void deleteArray_TUnfoldSys(void *p);
   static void destruct_TUnfoldSys(void *p);

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

namespace ROOT {
   void TVirtualGraphPainter_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TVirtualGraphPainter(void *p);
   static void deleteArray_TVirtualGraphPainter(void *p);
   static void destruct_TVirtualGraphPainter(void *p);

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

namespace ROOT {
   void ROOTcLcLMathcLcLWrappedMultiTF1_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void ROOTcLcLMathcLcLWrappedMultiTF1_Dictionary();
   static void delete_ROOTcLcLMathcLcLWrappedMultiTF1(void *p);
   static void deleteArray_ROOTcLcLMathcLcLWrappedMultiTF1(void *p);
   static void destruct_ROOTcLcLMathcLcLWrappedMultiTF1(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::WrappedMultiTF1*)
   {
      ::ROOT::Math::WrappedMultiTF1 *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::WrappedMultiTF1),0);
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::WrappedMultiTF1", "include/Math/WrappedMultiTF1.h", 39,
                  typeid(::ROOT::Math::WrappedMultiTF1), DefineBehavior(ptr, ptr),
                  0, &ROOTcLcLMathcLcLWrappedMultiTF1_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::WrappedMultiTF1) );
      instance.SetDelete(&delete_ROOTcLcLMathcLcLWrappedMultiTF1);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLWrappedMultiTF1);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLWrappedMultiTF1);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::WrappedMultiTF1*)
   {
      return GenerateInitInstanceLocal((::ROOT::Math::WrappedMultiTF1*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Math::WrappedMultiTF1*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void ROOTcLcLMathcLcLWrappedMultiTF1_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::WrappedMultiTF1*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void ROOTcLcLMathcLcLWrappedTF1_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void ROOTcLcLMathcLcLWrappedTF1_Dictionary();
   static void delete_ROOTcLcLMathcLcLWrappedTF1(void *p);
   static void deleteArray_ROOTcLcLMathcLcLWrappedTF1(void *p);
   static void destruct_ROOTcLcLMathcLcLWrappedTF1(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::WrappedTF1*)
   {
      ::ROOT::Math::WrappedTF1 *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::WrappedTF1),0);
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::WrappedTF1", "include/Math/WrappedTF1.h", 40,
                  typeid(::ROOT::Math::WrappedTF1), DefineBehavior(ptr, ptr),
                  0, &ROOTcLcLMathcLcLWrappedTF1_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::WrappedTF1) );
      instance.SetDelete(&delete_ROOTcLcLMathcLcLWrappedTF1);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLWrappedTF1);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLWrappedTF1);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::WrappedTF1*)
   {
      return GenerateInitInstanceLocal((::ROOT::Math::WrappedTF1*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Math::WrappedTF1*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void ROOTcLcLMathcLcLWrappedTF1_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::WrappedTF1*)0x0)->GetClass();
   }

} // end of namespace ROOT

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

//______________________________________________________________________________
template <> TClass *THnSparseT<TArrayD>::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
template <> const char *THnSparseT<TArrayD>::Class_Name()
{
   return "THnSparseT<TArrayD>";
}

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

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

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

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

//______________________________________________________________________________
template <> TClass *THnSparseT<TArrayF>::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
template <> const char *THnSparseT<TArrayF>::Class_Name()
{
   return "THnSparseT<TArrayF>";
}

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

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

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

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

//______________________________________________________________________________
template <> TClass *THnSparseT<TArrayL>::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
template <> const char *THnSparseT<TArrayL>::Class_Name()
{
   return "THnSparseT<TArrayL>";
}

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

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

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

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

//______________________________________________________________________________
template <> TClass *THnSparseT<TArrayI>::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
template <> const char *THnSparseT<TArrayI>::Class_Name()
{
   return "THnSparseT<TArrayI>";
}

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

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

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

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

//______________________________________________________________________________
template <> TClass *THnSparseT<TArrayS>::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
template <> const char *THnSparseT<TArrayS>::Class_Name()
{
   return "THnSparseT<TArrayS>";
}

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

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

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

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

//______________________________________________________________________________
template <> TClass *THnSparseT<TArrayC>::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
template <> const char *THnSparseT<TArrayC>::Class_Name()
{
   return "THnSparseT<TArrayC>";
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

//______________________________________________________________________________
void TAxis::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TAxis.
      TClass *R__cl = ::TAxis::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNbins", &fNbins);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXmin", &fXmin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXmax", &fXmax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXbins", &fXbins);
      R__insp.InspectMember(fXbins, "fXbins.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFirst", &fFirst);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLast", &fLast);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBits2", &fBits2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTimeDisplay", &fTimeDisplay);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTimeFormat", &fTimeFormat);
      R__insp.InspectMember(fTimeFormat, "fTimeFormat.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fParent", &fParent);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLabels", &fLabels);
      TNamed::ShowMembers(R__insp);
      TAttAxis::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TAxis(void *p) {
      return  p ? new(p) ::TAxis : new ::TAxis;
   }
   static void *newArray_TAxis(Long_t nElements, void *p) {
      return p ? new(p) ::TAxis[nElements] : new ::TAxis[nElements];
   }
   // Wrapper around operator delete
   static void delete_TAxis(void *p) {
      delete ((::TAxis*)p);
   }
   static void deleteArray_TAxis(void *p) {
      delete [] ((::TAxis*)p);
   }
   static void destruct_TAxis(void *p) {
      typedef ::TAxis current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TAxis(TBuffer &buf, void *obj) {
      ((::TAxis*)obj)->::TAxis::Streamer(buf);
   }
} // end of namespace ROOT for class ::TAxis

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

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

//______________________________________________________________________________
void TBinomialEfficiencyFitter::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TBinomialEfficiencyFitter.
      TClass *R__cl = ::TBinomialEfficiencyFitter::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDenominator", &fDenominator);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNumerator", &fNumerator);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFunction", &fFunction);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEpsilon", &fEpsilon);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFitDone", &fFitDone);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAverage", &fAverage);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRange", &fRange);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TBinomialEfficiencyFitter(void *p) {
      return  p ? new(p) ::TBinomialEfficiencyFitter : new ::TBinomialEfficiencyFitter;
   }
   static void *newArray_TBinomialEfficiencyFitter(Long_t nElements, void *p) {
      return p ? new(p) ::TBinomialEfficiencyFitter[nElements] : new ::TBinomialEfficiencyFitter[nElements];
   }
   // Wrapper around operator delete
   static void delete_TBinomialEfficiencyFitter(void *p) {
      delete ((::TBinomialEfficiencyFitter*)p);
   }
   static void deleteArray_TBinomialEfficiencyFitter(void *p) {
      delete [] ((::TBinomialEfficiencyFitter*)p);
   }
   static void destruct_TBinomialEfficiencyFitter(void *p) {
      typedef ::TBinomialEfficiencyFitter current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TBinomialEfficiencyFitter

//______________________________________________________________________________
void TFormula::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TFormula.
      TClass *R__cl = ::TFormula::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNdim", &fNdim);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNpar", &fNpar);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNoper", &fNoper);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNconst", &fNconst);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNumber", &fNumber);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNval", &fNval);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNstring", &fNstring);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fExpr", &fExpr);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOper", &fOper);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fConst", &fConst);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fParams", &fParams);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNames", &fNames);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFunctions", &fFunctions);
      R__insp.InspectMember(fFunctions, "fFunctions.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLinearParts", &fLinearParts);
      R__insp.InspectMember(fLinearParts, "fLinearParts.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAlreadyFound", &fAlreadyFound);
      R__insp.InspectMember(fAlreadyFound, "fAlreadyFound.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNOperOptimized", &fNOperOptimized);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fExprOptimized", &fExprOptimized);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOperOptimized", &fOperOptimized);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOperOffset", &fOperOffset);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPredefined", &fPredefined);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOptimal", &fOptimal);
      TNamed::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TFormula(void *p) {
      return  p ? new(p) ::TFormula : new ::TFormula;
   }
   static void *newArray_TFormula(Long_t nElements, void *p) {
      return p ? new(p) ::TFormula[nElements] : new ::TFormula[nElements];
   }
   // Wrapper around operator delete
   static void delete_TFormula(void *p) {
      delete ((::TFormula*)p);
   }
   static void deleteArray_TFormula(void *p) {
      delete [] ((::TFormula*)p);
   }
   static void destruct_TFormula(void *p) {
      typedef ::TFormula current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TFormula(TBuffer &buf, void *obj) {
      ((::TFormula*)obj)->::TFormula::Streamer(buf);
   }
} // end of namespace ROOT for class ::TFormula

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

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

//______________________________________________________________________________
void TFormulaPrimitive::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TFormulaPrimitive.
      TClass *R__cl = ::TFormulaPrimitive::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFuncG", &fFuncG);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFunc0", &fFunc0);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFunc10", &fFunc10);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFunc110", &fFunc110);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFunc1110", &fFunc1110);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTFuncG", &fTFuncG);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTFunc0", &fTFunc0);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTFunc10", &fTFunc10);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTFunc110", &fTFunc110);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTFunc1110", &fTFunc1110);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fType", &fType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNArguments", &fNArguments);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNParameters", &fNParameters);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsStatic", &fIsStatic);
      TNamed::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TFormulaPrimitive(void *p) {
      return  p ? new(p) ::TFormulaPrimitive : new ::TFormulaPrimitive;
   }
   static void *newArray_TFormulaPrimitive(Long_t nElements, void *p) {
      return p ? new(p) ::TFormulaPrimitive[nElements] : new ::TFormulaPrimitive[nElements];
   }
   // Wrapper around operator delete
   static void delete_TFormulaPrimitive(void *p) {
      delete ((::TFormulaPrimitive*)p);
   }
   static void deleteArray_TFormulaPrimitive(void *p) {
      delete [] ((::TFormulaPrimitive*)p);
   }
   static void destruct_TFormulaPrimitive(void *p) {
      typedef ::TFormulaPrimitive current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TFormulaPrimitive

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

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

//______________________________________________________________________________
void TFractionFitter::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TFractionFitter.
      TClass *R__cl = ::TFractionFitter::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFitDone", &fFitDone);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLowLimitX", &fLowLimitX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHighLimitX", &fHighLimitX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLowLimitY", &fLowLimitY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHighLimitY", &fHighLimitY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLowLimitZ", &fLowLimitZ);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHighLimitZ", &fHighLimitZ);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNpfits", &fNpfits);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNDF", &fNDF);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fChisquare", &fChisquare);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAji", &fAji);
      R__insp.InspectMember(fAji, "fAji.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fData", &fData);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMCs", &fMCs);
      R__insp.InspectMember(fMCs, "fMCs.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWeights", &fWeights);
      R__insp.InspectMember(fWeights, "fWeights.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIntegralData", &fIntegralData);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fIntegralMCs", &fIntegralMCs);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFractions", &fFractions);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPlot", &fPlot);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNpar", &fNpar);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TFractionFitter(void *p) {
      return  p ? new(p) ::TFractionFitter : new ::TFractionFitter;
   }
   static void *newArray_TFractionFitter(Long_t nElements, void *p) {
      return p ? new(p) ::TFractionFitter[nElements] : new ::TFractionFitter[nElements];
   }
   // Wrapper around operator delete
   static void delete_TFractionFitter(void *p) {
      delete ((::TFractionFitter*)p);
   }
   static void deleteArray_TFractionFitter(void *p) {
      delete [] ((::TFractionFitter*)p);
   }
   static void destruct_TFractionFitter(void *p) {
      typedef ::TFractionFitter current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TFractionFitter

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

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

//______________________________________________________________________________
void TFitResult::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TFitResult.
      TClass *R__cl = ::TFitResult::IsA();
      if (R__cl || R__insp.IsA()) { }
      TNamed::ShowMembers(R__insp);
      R__insp.GenericShowMembers("ROOT::Fit::FitResult", ( ::ROOT::Fit::FitResult *) (this ), false);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TFitResult(void *p) {
      return  p ? new(p) ::TFitResult : new ::TFitResult;
   }
   static void *newArray_TFitResult(Long_t nElements, void *p) {
      return p ? new(p) ::TFitResult[nElements] : new ::TFitResult[nElements];
   }
   // Wrapper around operator delete
   static void delete_TFitResult(void *p) {
      delete ((::TFitResult*)p);
   }
   static void deleteArray_TFitResult(void *p) {
      delete [] ((::TFitResult*)p);
   }
   static void destruct_TFitResult(void *p) {
      typedef ::TFitResult current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TFitResult

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TFitResultPtr(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TFitResultPtr : new ::TFitResultPtr;
   }
   static void *newArray_TFitResultPtr(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TFitResultPtr[nElements] : new ::TFitResultPtr[nElements];
   }
   // Wrapper around operator delete
   static void delete_TFitResultPtr(void *p) {
      delete ((::TFitResultPtr*)p);
   }
   static void deleteArray_TFitResultPtr(void *p) {
      delete [] ((::TFitResultPtr*)p);
   }
   static void destruct_TFitResultPtr(void *p) {
      typedef ::TFitResultPtr current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TFitResultPtr

//______________________________________________________________________________
void TF1::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TF1.
      TClass *R__cl = ::TF1::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXmin", &fXmin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXmax", &fXmax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNpx", &fNpx);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fType", &fType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNpfits", &fNpfits);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNDF", &fNDF);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNsave", &fNsave);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fChisquare", &fChisquare);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fIntegral", &fIntegral);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fParErrors", &fParErrors);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fParMin", &fParMin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fParMax", &fParMax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSave", &fSave);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAlpha", &fAlpha);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBeta", &fBeta);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGamma", &fGamma);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fParent", &fParent);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHistogram", &fHistogram);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaximum", &fMaximum);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinimum", &fMinimum);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMethodCall", &fMethodCall);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCintFunc", &fCintFunc);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFunctor", (void*)&fFunctor);
      R__insp.InspectMember("ROOT::Math::ParamFunctor", (void*)&fFunctor, "fFunctor.", true);
      TFormula::ShowMembers(R__insp);
      TAttLine::ShowMembers(R__insp);
      TAttFill::ShowMembers(R__insp);
      TAttMarker::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TF1(void *p) {
      return  p ? new(p) ::TF1 : new ::TF1;
   }
   static void *newArray_TF1(Long_t nElements, void *p) {
      return p ? new(p) ::TF1[nElements] : new ::TF1[nElements];
   }
   // Wrapper around operator delete
   static void delete_TF1(void *p) {
      delete ((::TF1*)p);
   }
   static void deleteArray_TF1(void *p) {
      delete [] ((::TF1*)p);
   }
   static void destruct_TF1(void *p) {
      typedef ::TF1 current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TF1(TBuffer &buf, void *obj) {
      ((::TF1*)obj)->::TF1::Streamer(buf);
   }
} // end of namespace ROOT for class ::TF1

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

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

//______________________________________________________________________________
void TF12::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TF12.
      TClass *R__cl = ::TF12::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXY", &fXY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCase", &fCase);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fF2", &fF2);
      TF1::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TF12(void *p) {
      return  p ? new(p) ::TF12 : new ::TF12;
   }
   static void *newArray_TF12(Long_t nElements, void *p) {
      return p ? new(p) ::TF12[nElements] : new ::TF12[nElements];
   }
   // Wrapper around operator delete
   static void delete_TF12(void *p) {
      delete ((::TF12*)p);
   }
   static void deleteArray_TF12(void *p) {
      delete [] ((::TF12*)p);
   }
   static void destruct_TF12(void *p) {
      typedef ::TF12 current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TF12

//______________________________________________________________________________
void TF2::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TF2.
      TClass *R__cl = ::TF2::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fYmin", &fYmin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fYmax", &fYmax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNpy", &fNpy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fContour", &fContour);
      R__insp.InspectMember(fContour, "fContour.");
      TF1::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TF2(void *p) {
      return  p ? new(p) ::TF2 : new ::TF2;
   }
   static void *newArray_TF2(Long_t nElements, void *p) {
      return p ? new(p) ::TF2[nElements] : new ::TF2[nElements];
   }
   // Wrapper around operator delete
   static void delete_TF2(void *p) {
      delete ((::TF2*)p);
   }
   static void deleteArray_TF2(void *p) {
      delete [] ((::TF2*)p);
   }
   static void destruct_TF2(void *p) {
      typedef ::TF2 current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TF2(TBuffer &buf, void *obj) {
      ((::TF2*)obj)->::TF2::Streamer(buf);
   }
} // end of namespace ROOT for class ::TF2

//______________________________________________________________________________
void TF3::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TF3.
      TClass *R__cl = ::TF3::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fZmin", &fZmin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fZmax", &fZmax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNpz", &fNpz);
      TF2::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TF3(void *p) {
      return  p ? new(p) ::TF3 : new ::TF3;
   }
   static void *newArray_TF3(Long_t nElements, void *p) {
      return p ? new(p) ::TF3[nElements] : new ::TF3[nElements];
   }
   // Wrapper around operator delete
   static void delete_TF3(void *p) {
      delete ((::TF3*)p);
   }
   static void deleteArray_TF3(void *p) {
      delete [] ((::TF3*)p);
   }
   static void destruct_TF3(void *p) {
      typedef ::TF3 current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TF3(TBuffer &buf, void *obj) {
      ((::TF3*)obj)->::TF3::Streamer(buf);
   }
} // end of namespace ROOT for class ::TF3

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

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::Foption_t*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "Quiet", &sobj->Quiet);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "Verbose", &sobj->Verbose);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "Bound", &sobj->Bound);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "Chi2", &sobj->Chi2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "Like", &sobj->Like);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "User", &sobj->User);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "W1", &sobj->W1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "Errors", &sobj->Errors);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "More", &sobj->More);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "Range", &sobj->Range);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "Gradient", &sobj->Gradient);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "Nostore", &sobj->Nostore);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "Nograph", &sobj->Nograph);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "Plus", &sobj->Plus);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "Integral", &sobj->Integral);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "Nochisq", &sobj->Nochisq);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "Minuit", &sobj->Minuit);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "NoErrX", &sobj->NoErrX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "Robust", &sobj->Robust);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "StoreResult", &sobj->StoreResult);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "hRobust", &sobj->hRobust);
   }

}

namespace ROOT {
   // Wrappers around operator new
   static void *new_Foption_t(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::Foption_t : new ::Foption_t;
   }
   static void *newArray_Foption_t(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::Foption_t[nElements] : new ::Foption_t[nElements];
   }
   // Wrapper around operator delete
   static void delete_Foption_t(void *p) {
      delete ((::Foption_t*)p);
   }
   static void deleteArray_Foption_t(void *p) {
      delete [] ((::Foption_t*)p);
   }
   static void destruct_Foption_t(void *p) {
      typedef ::Foption_t current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::Foption_t

//______________________________________________________________________________
void TGraph::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGraph.
      TClass *R__cl = ::TGraph::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxSize", &fMaxSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNpoints", &fNpoints);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fX", &fX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fY", &fY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFunctions", &fFunctions);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHistogram", &fHistogram);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinimum", &fMinimum);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaximum", &fMaximum);
      TNamed::ShowMembers(R__insp);
      TAttLine::ShowMembers(R__insp);
      TAttFill::ShowMembers(R__insp);
      TAttMarker::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGraph(void *p) {
      return  p ? new(p) ::TGraph : new ::TGraph;
   }
   static void *newArray_TGraph(Long_t nElements, void *p) {
      return p ? new(p) ::TGraph[nElements] : new ::TGraph[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGraph(void *p) {
      delete ((::TGraph*)p);
   }
   static void deleteArray_TGraph(void *p) {
      delete [] ((::TGraph*)p);
   }
   static void destruct_TGraph(void *p) {
      typedef ::TGraph current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGraph(TBuffer &buf, void *obj) {
      ((::TGraph*)obj)->::TGraph::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGraph

//______________________________________________________________________________
void TGraphErrors::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGraphErrors.
      TClass *R__cl = ::TGraphErrors::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEX", &fEX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEY", &fEY);
      TGraph::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGraphErrors(void *p) {
      return  p ? new(p) ::TGraphErrors : new ::TGraphErrors;
   }
   static void *newArray_TGraphErrors(Long_t nElements, void *p) {
      return p ? new(p) ::TGraphErrors[nElements] : new ::TGraphErrors[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGraphErrors(void *p) {
      delete ((::TGraphErrors*)p);
   }
   static void deleteArray_TGraphErrors(void *p) {
      delete [] ((::TGraphErrors*)p);
   }
   static void destruct_TGraphErrors(void *p) {
      typedef ::TGraphErrors current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGraphErrors(TBuffer &buf, void *obj) {
      ((::TGraphErrors*)obj)->::TGraphErrors::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGraphErrors

//______________________________________________________________________________
void TGraphAsymmErrors::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGraphAsymmErrors.
      TClass *R__cl = ::TGraphAsymmErrors::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEXlow", &fEXlow);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEXhigh", &fEXhigh);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEYlow", &fEYlow);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEYhigh", &fEYhigh);
      TGraph::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGraphAsymmErrors(void *p) {
      return  p ? new(p) ::TGraphAsymmErrors : new ::TGraphAsymmErrors;
   }
   static void *newArray_TGraphAsymmErrors(Long_t nElements, void *p) {
      return p ? new(p) ::TGraphAsymmErrors[nElements] : new ::TGraphAsymmErrors[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGraphAsymmErrors(void *p) {
      delete ((::TGraphAsymmErrors*)p);
   }
   static void deleteArray_TGraphAsymmErrors(void *p) {
      delete [] ((::TGraphAsymmErrors*)p);
   }
   static void destruct_TGraphAsymmErrors(void *p) {
      typedef ::TGraphAsymmErrors current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGraphAsymmErrors(TBuffer &buf, void *obj) {
      ((::TGraphAsymmErrors*)obj)->::TGraphAsymmErrors::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGraphAsymmErrors

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

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

//______________________________________________________________________________
void TGraphBentErrors::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGraphBentErrors.
      TClass *R__cl = ::TGraphBentErrors::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEXlow", &fEXlow);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEXhigh", &fEXhigh);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEYlow", &fEYlow);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEYhigh", &fEYhigh);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEXlowd", &fEXlowd);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEXhighd", &fEXhighd);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEYlowd", &fEYlowd);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEYhighd", &fEYhighd);
      TGraph::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGraphBentErrors(void *p) {
      return  p ? new(p) ::TGraphBentErrors : new ::TGraphBentErrors;
   }
   static void *newArray_TGraphBentErrors(Long_t nElements, void *p) {
      return p ? new(p) ::TGraphBentErrors[nElements] : new ::TGraphBentErrors[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGraphBentErrors(void *p) {
      delete ((::TGraphBentErrors*)p);
   }
   static void deleteArray_TGraphBentErrors(void *p) {
      delete [] ((::TGraphBentErrors*)p);
   }
   static void destruct_TGraphBentErrors(void *p) {
      typedef ::TGraphBentErrors current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGraphBentErrors

//______________________________________________________________________________
void TGraph2D::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGraph2D.
      TClass *R__cl = ::TGraph2D::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNpoints", &fNpoints);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNpx", &fNpx);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNpy", &fNpy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxIter", &fMaxIter);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSize", &fSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fX", &fX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fY", &fY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fZ", &fZ);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinimum", &fMinimum);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaximum", &fMaximum);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMargin", &fMargin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fZout", &fZout);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFunctions", &fFunctions);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHistogram", &fHistogram);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDirectory", &fDirectory);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPainter", &fPainter);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUserHisto", &fUserHisto);
      TNamed::ShowMembers(R__insp);
      TAttLine::ShowMembers(R__insp);
      TAttFill::ShowMembers(R__insp);
      TAttMarker::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGraph2D(void *p) {
      return  p ? new(p) ::TGraph2D : new ::TGraph2D;
   }
   static void *newArray_TGraph2D(Long_t nElements, void *p) {
      return p ? new(p) ::TGraph2D[nElements] : new ::TGraph2D[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGraph2D(void *p) {
      delete ((::TGraph2D*)p);
   }
   static void deleteArray_TGraph2D(void *p) {
      delete [] ((::TGraph2D*)p);
   }
   static void destruct_TGraph2D(void *p) {
      typedef ::TGraph2D current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around the directory auto add.
   static void directoryAutoAdd_TGraph2D(void *p, TDirectory *dir) {
      ((::TGraph2D*)p)->DirectoryAutoAdd(dir);
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGraph2D(TBuffer &buf, void *obj) {
      ((::TGraph2D*)obj)->::TGraph2D::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGraph2D

//______________________________________________________________________________
void TGraph2DErrors::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGraph2DErrors.
      TClass *R__cl = ::TGraph2DErrors::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEX", &fEX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEY", &fEY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEZ", &fEZ);
      TGraph2D::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGraph2DErrors(void *p) {
      return  p ? new(p) ::TGraph2DErrors : new ::TGraph2DErrors;
   }
   static void *newArray_TGraph2DErrors(Long_t nElements, void *p) {
      return p ? new(p) ::TGraph2DErrors[nElements] : new ::TGraph2DErrors[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGraph2DErrors(void *p) {
      delete ((::TGraph2DErrors*)p);
   }
   static void deleteArray_TGraph2DErrors(void *p) {
      delete [] ((::TGraph2DErrors*)p);
   }
   static void destruct_TGraph2DErrors(void *p) {
      typedef ::TGraph2DErrors current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around the directory auto add.
   static void directoryAutoAdd_TGraph2DErrors(void *p, TDirectory *dir) {
      ((::TGraph2DErrors*)p)->DirectoryAutoAdd(dir);
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGraph2DErrors(TBuffer &buf, void *obj) {
      ((::TGraph2DErrors*)obj)->::TGraph2DErrors::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGraph2DErrors

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

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

//______________________________________________________________________________
void TGraphDelaunay::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGraphDelaunay.
      TClass *R__cl = ::TGraphDelaunay::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNdt", &fNdt);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNpoints", &fNpoints);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNhull", &fNhull);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fX", &fX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fY", &fY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fZ", &fZ);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fXN", &fXN);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fYN", &fYN);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXNmin", &fXNmin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXNmax", &fXNmax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fYNmin", &fYNmin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fYNmax", &fYNmax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXoffset", &fXoffset);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fYoffset", &fYoffset);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXScaleFactor", &fXScaleFactor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fYScaleFactor", &fYScaleFactor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fZout", &fZout);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDist", &fDist);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxIter", &fMaxIter);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTriedSize", &fTriedSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPTried", &fPTried);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNTried", &fNTried);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMTried", &fMTried);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHullPoints", &fHullPoints);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOrder", &fOrder);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAllTri", &fAllTri);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInit", &fInit);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGraph2D", &fGraph2D);
      TNamed::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGraphDelaunay(void *p) {
      return  p ? new(p) ::TGraphDelaunay : new ::TGraphDelaunay;
   }
   static void *newArray_TGraphDelaunay(Long_t nElements, void *p) {
      return p ? new(p) ::TGraphDelaunay[nElements] : new ::TGraphDelaunay[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGraphDelaunay(void *p) {
      delete ((::TGraphDelaunay*)p);
   }
   static void deleteArray_TGraphDelaunay(void *p) {
      delete [] ((::TGraphDelaunay*)p);
   }
   static void destruct_TGraphDelaunay(void *p) {
      typedef ::TGraphDelaunay current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGraphDelaunay

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

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

//______________________________________________________________________________
void TGraphSmooth::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGraphSmooth.
      TClass *R__cl = ::TGraphSmooth::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNin", &fNin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNout", &fNout);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGin", &fGin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGout", &fGout);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinX", &fMinX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxX", &fMaxX);
      TNamed::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGraphSmooth(void *p) {
      return  p ? new(p) ::TGraphSmooth : new ::TGraphSmooth;
   }
   static void *newArray_TGraphSmooth(Long_t nElements, void *p) {
      return p ? new(p) ::TGraphSmooth[nElements] : new ::TGraphSmooth[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGraphSmooth(void *p) {
      delete ((::TGraphSmooth*)p);
   }
   static void deleteArray_TGraphSmooth(void *p) {
      delete [] ((::TGraphSmooth*)p);
   }
   static void destruct_TGraphSmooth(void *p) {
      typedef ::TGraphSmooth current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGraphSmooth

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

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

//______________________________________________________________________________
void TGraphTime::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGraphTime.
      TClass *R__cl = ::TGraphTime::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSleepTime", &fSleepTime);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNsteps", &fNsteps);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXmin", &fXmin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXmax", &fXmax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fYmin", &fYmin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fYmax", &fYmax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSteps", &fSteps);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFrame", &fFrame);
      TNamed::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGraphTime(void *p) {
      return  p ? new(p) ::TGraphTime : new ::TGraphTime;
   }
   static void *newArray_TGraphTime(Long_t nElements, void *p) {
      return p ? new(p) ::TGraphTime[nElements] : new ::TGraphTime[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGraphTime(void *p) {
      delete ((::TGraphTime*)p);
   }
   static void deleteArray_TGraphTime(void *p) {
      delete [] ((::TGraphTime*)p);
   }
   static void destruct_TGraphTime(void *p) {
      typedef ::TGraphTime current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGraphTime

//______________________________________________________________________________
void TH1::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TH1.
      TClass *R__cl = ::TH1::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNcells", &fNcells);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXaxis", &fXaxis);
      R__insp.InspectMember(fXaxis, "fXaxis.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fYaxis", &fYaxis);
      R__insp.InspectMember(fYaxis, "fYaxis.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fZaxis", &fZaxis);
      R__insp.InspectMember(fZaxis, "fZaxis.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBarOffset", &fBarOffset);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBarWidth", &fBarWidth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEntries", &fEntries);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTsumw", &fTsumw);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTsumw2", &fTsumw2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTsumwx", &fTsumwx);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTsumwx2", &fTsumwx2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaximum", &fMaximum);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinimum", &fMinimum);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNormFactor", &fNormFactor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fContour", &fContour);
      R__insp.InspectMember(fContour, "fContour.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSumw2", &fSumw2);
      R__insp.InspectMember(fSumw2, "fSumw2.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOption", &fOption);
      R__insp.InspectMember(fOption, "fOption.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFunctions", &fFunctions);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBufferSize", &fBufferSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBuffer", &fBuffer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDirectory", &fDirectory);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDimension", &fDimension);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fIntegral", &fIntegral);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPainter", &fPainter);
      TNamed::ShowMembers(R__insp);
      TAttLine::ShowMembers(R__insp);
      TAttFill::ShowMembers(R__insp);
      TAttMarker::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TH1(void *p) {
      delete ((::TH1*)p);
   }
   static void deleteArray_TH1(void *p) {
      delete [] ((::TH1*)p);
   }
   static void destruct_TH1(void *p) {
      typedef ::TH1 current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around the directory auto add.
   static void directoryAutoAdd_TH1(void *p, TDirectory *dir) {
      ((::TH1*)p)->DirectoryAutoAdd(dir);
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TH1(TBuffer &buf, void *obj) {
      ((::TH1*)obj)->::TH1::Streamer(buf);
   }
} // end of namespace ROOT for class ::TH1

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TH1C(void *p) {
      return  p ? new(p) ::TH1C : new ::TH1C;
   }
   static void *newArray_TH1C(Long_t nElements, void *p) {
      return p ? new(p) ::TH1C[nElements] : new ::TH1C[nElements];
   }
   // Wrapper around operator delete
   static void delete_TH1C(void *p) {
      delete ((::TH1C*)p);
   }
   static void deleteArray_TH1C(void *p) {
      delete [] ((::TH1C*)p);
   }
   static void destruct_TH1C(void *p) {
      typedef ::TH1C current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around the directory auto add.
   static void directoryAutoAdd_TH1C(void *p, TDirectory *dir) {
      ((::TH1C*)p)->DirectoryAutoAdd(dir);
   }
} // end of namespace ROOT for class ::TH1C

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TH1D(void *p) {
      return  p ? new(p) ::TH1D : new ::TH1D;
   }
   static void *newArray_TH1D(Long_t nElements, void *p) {
      return p ? new(p) ::TH1D[nElements] : new ::TH1D[nElements];
   }
   // Wrapper around operator delete
   static void delete_TH1D(void *p) {
      delete ((::TH1D*)p);
   }
   static void deleteArray_TH1D(void *p) {
      delete [] ((::TH1D*)p);
   }
   static void destruct_TH1D(void *p) {
      typedef ::TH1D current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around the directory auto add.
   static void directoryAutoAdd_TH1D(void *p, TDirectory *dir) {
      ((::TH1D*)p)->DirectoryAutoAdd(dir);
   }
} // end of namespace ROOT for class ::TH1D

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TH1F(void *p) {
      return  p ? new(p) ::TH1F : new ::TH1F;
   }
   static void *newArray_TH1F(Long_t nElements, void *p) {
      return p ? new(p) ::TH1F[nElements] : new ::TH1F[nElements];
   }
   // Wrapper around operator delete
   static void delete_TH1F(void *p) {
      delete ((::TH1F*)p);
   }
   static void deleteArray_TH1F(void *p) {
      delete [] ((::TH1F*)p);
   }
   static void destruct_TH1F(void *p) {
      typedef ::TH1F current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around the directory auto add.
   static void directoryAutoAdd_TH1F(void *p, TDirectory *dir) {
      ((::TH1F*)p)->DirectoryAutoAdd(dir);
   }
} // end of namespace ROOT for class ::TH1F

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TH1S(void *p) {
      return  p ? new(p) ::TH1S : new ::TH1S;
   }
   static void *newArray_TH1S(Long_t nElements, void *p) {
      return p ? new(p) ::TH1S[nElements] : new ::TH1S[nElements];
   }
   // Wrapper around operator delete
   static void delete_TH1S(void *p) {
      delete ((::TH1S*)p);
   }
   static void deleteArray_TH1S(void *p) {
      delete [] ((::TH1S*)p);
   }
   static void destruct_TH1S(void *p) {
      typedef ::TH1S current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around the directory auto add.
   static void directoryAutoAdd_TH1S(void *p, TDirectory *dir) {
      ((::TH1S*)p)->DirectoryAutoAdd(dir);
   }
} // end of namespace ROOT for class ::TH1S

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TH1I(void *p) {
      return  p ? new(p) ::TH1I : new ::TH1I;
   }
   static void *newArray_TH1I(Long_t nElements, void *p) {
      return p ? new(p) ::TH1I[nElements] : new ::TH1I[nElements];
   }
   // Wrapper around operator delete
   static void delete_TH1I(void *p) {
      delete ((::TH1I*)p);
   }
   static void deleteArray_TH1I(void *p) {
      delete [] ((::TH1I*)p);
   }
   static void destruct_TH1I(void *p) {
      typedef ::TH1I current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around the directory auto add.
   static void directoryAutoAdd_TH1I(void *p, TDirectory *dir) {
      ((::TH1I*)p)->DirectoryAutoAdd(dir);
   }
} // end of namespace ROOT for class ::TH1I

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

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

//______________________________________________________________________________
void TH1K::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TH1K.
      TClass *R__cl = ::TH1K::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fReady", &fReady);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNIn", &fNIn);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fKOrd", &fKOrd);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fKCur", &fKCur);
      TH1::ShowMembers(R__insp);
      TArrayF::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TH1K(void *p) {
      return  p ? new(p) ::TH1K : new ::TH1K;
   }
   static void *newArray_TH1K(Long_t nElements, void *p) {
      return p ? new(p) ::TH1K[nElements] : new ::TH1K[nElements];
   }
   // Wrapper around operator delete
   static void delete_TH1K(void *p) {
      delete ((::TH1K*)p);
   }
   static void deleteArray_TH1K(void *p) {
      delete [] ((::TH1K*)p);
   }
   static void destruct_TH1K(void *p) {
      typedef ::TH1K current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around the directory auto add.
   static void directoryAutoAdd_TH1K(void *p, TDirectory *dir) {
      ((::TH1K*)p)->DirectoryAutoAdd(dir);
   }
} // end of namespace ROOT for class ::TH1K

//______________________________________________________________________________
void TH2::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TH2.
      TClass *R__cl = ::TH2::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fScalefactor", &fScalefactor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTsumwy", &fTsumwy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTsumwy2", &fTsumwy2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTsumwxy", &fTsumwxy);
      TH1::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TH2(void *p) {
      delete ((::TH2*)p);
   }
   static void deleteArray_TH2(void *p) {
      delete [] ((::TH2*)p);
   }
   static void destruct_TH2(void *p) {
      typedef ::TH2 current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around the directory auto add.
   static void directoryAutoAdd_TH2(void *p, TDirectory *dir) {
      ((::TH2*)p)->DirectoryAutoAdd(dir);
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TH2(TBuffer &buf, void *obj) {
      ((::TH2*)obj)->::TH2::Streamer(buf);
   }
} // end of namespace ROOT for class ::TH2

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TH2C(void *p) {
      return  p ? new(p) ::TH2C : new ::TH2C;
   }
   static void *newArray_TH2C(Long_t nElements, void *p) {
      return p ? new(p) ::TH2C[nElements] : new ::TH2C[nElements];
   }
   // Wrapper around operator delete
   static void delete_TH2C(void *p) {
      delete ((::TH2C*)p);
   }
   static void deleteArray_TH2C(void *p) {
      delete [] ((::TH2C*)p);
   }
   static void destruct_TH2C(void *p) {
      typedef ::TH2C current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around the directory auto add.
   static void directoryAutoAdd_TH2C(void *p, TDirectory *dir) {
      ((::TH2C*)p)->DirectoryAutoAdd(dir);
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TH2C(TBuffer &buf, void *obj) {
      ((::TH2C*)obj)->::TH2C::Streamer(buf);
   }
} // end of namespace ROOT for class ::TH2C

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TH2D(void *p) {
      return  p ? new(p) ::TH2D : new ::TH2D;
   }
   static void *newArray_TH2D(Long_t nElements, void *p) {
      return p ? new(p) ::TH2D[nElements] : new ::TH2D[nElements];
   }
   // Wrapper around operator delete
   static void delete_TH2D(void *p) {
      delete ((::TH2D*)p);
   }
   static void deleteArray_TH2D(void *p) {
      delete [] ((::TH2D*)p);
   }
   static void destruct_TH2D(void *p) {
      typedef ::TH2D current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around the directory auto add.
   static void directoryAutoAdd_TH2D(void *p, TDirectory *dir) {
      ((::TH2D*)p)->DirectoryAutoAdd(dir);
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TH2D(TBuffer &buf, void *obj) {
      ((::TH2D*)obj)->::TH2D::Streamer(buf);
   }
} // end of namespace ROOT for class ::TH2D

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TH2F(void *p) {
      return  p ? new(p) ::TH2F : new ::TH2F;
   }
   static void *newArray_TH2F(Long_t nElements, void *p) {
      return p ? new(p) ::TH2F[nElements] : new ::TH2F[nElements];
   }
   // Wrapper around operator delete
   static void delete_TH2F(void *p) {
      delete ((::TH2F*)p);
   }
   static void deleteArray_TH2F(void *p) {
      delete [] ((::TH2F*)p);
   }
   static void destruct_TH2F(void *p) {
      typedef ::TH2F current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around the directory auto add.
   static void directoryAutoAdd_TH2F(void *p, TDirectory *dir) {
      ((::TH2F*)p)->DirectoryAutoAdd(dir);
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TH2F(TBuffer &buf, void *obj) {
      ((::TH2F*)obj)->::TH2F::Streamer(buf);
   }
} // end of namespace ROOT for class ::TH2F

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

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

//______________________________________________________________________________
void TH2Poly::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TH2Poly.
      TClass *R__cl = ::TH2Poly::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBins", &fBins);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOverflow[9]", fOverflow);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCellX", &fCellX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCellY", &fCellY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNCells", &fNCells);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCells", &fCells);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStepX", &fStepX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStepY", &fStepY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fIsEmpty", &fIsEmpty);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCompletelyInside", &fCompletelyInside);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFloat", &fFloat);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNewBinAdded", &fNewBinAdded);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBinContentChanged", &fBinContentChanged);
      TH2::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TH2Poly(void *p) {
      return  p ? new(p) ::TH2Poly : new ::TH2Poly;
   }
   static void *newArray_TH2Poly(Long_t nElements, void *p) {
      return p ? new(p) ::TH2Poly[nElements] : new ::TH2Poly[nElements];
   }
   // Wrapper around operator delete
   static void delete_TH2Poly(void *p) {
      delete ((::TH2Poly*)p);
   }
   static void deleteArray_TH2Poly(void *p) {
      delete [] ((::TH2Poly*)p);
   }
   static void destruct_TH2Poly(void *p) {
      typedef ::TH2Poly current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around the directory auto add.
   static void directoryAutoAdd_TH2Poly(void *p, TDirectory *dir) {
      ((::TH2Poly*)p)->DirectoryAutoAdd(dir);
   }
} // end of namespace ROOT for class ::TH2Poly

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

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

//______________________________________________________________________________
void TH2PolyBin::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TH2PolyBin.
      TClass *R__cl = ::TH2PolyBin::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fChanged", &fChanged);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNumber", &fNumber);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPoly", &fPoly);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fArea", &fArea);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fContent", &fContent);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXmin", &fXmin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fYmin", &fYmin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXmax", &fXmax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fYmax", &fYmax);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TH2PolyBin(void *p) {
      return  p ? new(p) ::TH2PolyBin : new ::TH2PolyBin;
   }
   static void *newArray_TH2PolyBin(Long_t nElements, void *p) {
      return p ? new(p) ::TH2PolyBin[nElements] : new ::TH2PolyBin[nElements];
   }
   // Wrapper around operator delete
   static void delete_TH2PolyBin(void *p) {
      delete ((::TH2PolyBin*)p);
   }
   static void deleteArray_TH2PolyBin(void *p) {
      delete [] ((::TH2PolyBin*)p);
   }
   static void destruct_TH2PolyBin(void *p) {
      typedef ::TH2PolyBin current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TH2PolyBin

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TH2S(void *p) {
      return  p ? new(p) ::TH2S : new ::TH2S;
   }
   static void *newArray_TH2S(Long_t nElements, void *p) {
      return p ? new(p) ::TH2S[nElements] : new ::TH2S[nElements];
   }
   // Wrapper around operator delete
   static void delete_TH2S(void *p) {
      delete ((::TH2S*)p);
   }
   static void deleteArray_TH2S(void *p) {
      delete [] ((::TH2S*)p);
   }
   static void destruct_TH2S(void *p) {
      typedef ::TH2S current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around the directory auto add.
   static void directoryAutoAdd_TH2S(void *p, TDirectory *dir) {
      ((::TH2S*)p)->DirectoryAutoAdd(dir);
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TH2S(TBuffer &buf, void *obj) {
      ((::TH2S*)obj)->::TH2S::Streamer(buf);
   }
} // end of namespace ROOT for class ::TH2S

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TH2I(void *p) {
      return  p ? new(p) ::TH2I : new ::TH2I;
   }
   static void *newArray_TH2I(Long_t nElements, void *p) {
      return p ? new(p) ::TH2I[nElements] : new ::TH2I[nElements];
   }
   // Wrapper around operator delete
   static void delete_TH2I(void *p) {
      delete ((::TH2I*)p);
   }
   static void deleteArray_TH2I(void *p) {
      delete [] ((::TH2I*)p);
   }
   static void destruct_TH2I(void *p) {
      typedef ::TH2I current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around the directory auto add.
   static void directoryAutoAdd_TH2I(void *p, TDirectory *dir) {
      ((::TH2I*)p)->DirectoryAutoAdd(dir);
   }
} // end of namespace ROOT for class ::TH2I

//______________________________________________________________________________
void TH3::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TH3.
      TClass *R__cl = ::TH3::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTsumwy", &fTsumwy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTsumwy2", &fTsumwy2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTsumwxy", &fTsumwxy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTsumwz", &fTsumwz);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTsumwz2", &fTsumwz2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTsumwxz", &fTsumwxz);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTsumwyz", &fTsumwyz);
      TH1::ShowMembers(R__insp);
      TAtt3D::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TH3(void *p) {
      delete ((::TH3*)p);
   }
   static void deleteArray_TH3(void *p) {
      delete [] ((::TH3*)p);
   }
   static void destruct_TH3(void *p) {
      typedef ::TH3 current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around the directory auto add.
   static void directoryAutoAdd_TH3(void *p, TDirectory *dir) {
      ((::TH3*)p)->DirectoryAutoAdd(dir);
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TH3(TBuffer &buf, void *obj) {
      ((::TH3*)obj)->::TH3::Streamer(buf);
   }
} // end of namespace ROOT for class ::TH3

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TH3C(void *p) {
      return  p ? new(p) ::TH3C : new ::TH3C;
   }
   static void *newArray_TH3C(Long_t nElements, void *p) {
      return p ? new(p) ::TH3C[nElements] : new ::TH3C[nElements];
   }
   // Wrapper around operator delete
   static void delete_TH3C(void *p) {
      delete ((::TH3C*)p);
   }
   static void deleteArray_TH3C(void *p) {
      delete [] ((::TH3C*)p);
   }
   static void destruct_TH3C(void *p) {
      typedef ::TH3C current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around the directory auto add.
   static void directoryAutoAdd_TH3C(void *p, TDirectory *dir) {
      ((::TH3C*)p)->DirectoryAutoAdd(dir);
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TH3C(TBuffer &buf, void *obj) {
      ((::TH3C*)obj)->::TH3C::Streamer(buf);
   }
} // end of namespace ROOT for class ::TH3C

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TH3D(void *p) {
      return  p ? new(p) ::TH3D : new ::TH3D;
   }
   static void *newArray_TH3D(Long_t nElements, void *p) {
      return p ? new(p) ::TH3D[nElements] : new ::TH3D[nElements];
   }
   // Wrapper around operator delete
   static void delete_TH3D(void *p) {
      delete ((::TH3D*)p);
   }
   static void deleteArray_TH3D(void *p) {
      delete [] ((::TH3D*)p);
   }
   static void destruct_TH3D(void *p) {
      typedef ::TH3D current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around the directory auto add.
   static void directoryAutoAdd_TH3D(void *p, TDirectory *dir) {
      ((::TH3D*)p)->DirectoryAutoAdd(dir);
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TH3D(TBuffer &buf, void *obj) {
      ((::TH3D*)obj)->::TH3D::Streamer(buf);
   }
} // end of namespace ROOT for class ::TH3D

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TH3F(void *p) {
      return  p ? new(p) ::TH3F : new ::TH3F;
   }
   static void *newArray_TH3F(Long_t nElements, void *p) {
      return p ? new(p) ::TH3F[nElements] : new ::TH3F[nElements];
   }
   // Wrapper around operator delete
   static void delete_TH3F(void *p) {
      delete ((::TH3F*)p);
   }
   static void deleteArray_TH3F(void *p) {
      delete [] ((::TH3F*)p);
   }
   static void destruct_TH3F(void *p) {
      typedef ::TH3F current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around the directory auto add.
   static void directoryAutoAdd_TH3F(void *p, TDirectory *dir) {
      ((::TH3F*)p)->DirectoryAutoAdd(dir);
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TH3F(TBuffer &buf, void *obj) {
      ((::TH3F*)obj)->::TH3F::Streamer(buf);
   }
} // end of namespace ROOT for class ::TH3F

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TH3S(void *p) {
      return  p ? new(p) ::TH3S : new ::TH3S;
   }
   static void *newArray_TH3S(Long_t nElements, void *p) {
      return p ? new(p) ::TH3S[nElements] : new ::TH3S[nElements];
   }
   // Wrapper around operator delete
   static void delete_TH3S(void *p) {
      delete ((::TH3S*)p);
   }
   static void deleteArray_TH3S(void *p) {
      delete [] ((::TH3S*)p);
   }
   static void destruct_TH3S(void *p) {
      typedef ::TH3S current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around the directory auto add.
   static void directoryAutoAdd_TH3S(void *p, TDirectory *dir) {
      ((::TH3S*)p)->DirectoryAutoAdd(dir);
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TH3S(TBuffer &buf, void *obj) {
      ((::TH3S*)obj)->::TH3S::Streamer(buf);
   }
} // end of namespace ROOT for class ::TH3S

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TH3I(void *p) {
      return  p ? new(p) ::TH3I : new ::TH3I;
   }
   static void *newArray_TH3I(Long_t nElements, void *p) {
      return p ? new(p) ::TH3I[nElements] : new ::TH3I[nElements];
   }
   // Wrapper around operator delete
   static void delete_TH3I(void *p) {
      delete ((::TH3I*)p);
   }
   static void deleteArray_TH3I(void *p) {
      delete [] ((::TH3I*)p);
   }
   static void destruct_TH3I(void *p) {
      typedef ::TH3I current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around the directory auto add.
   static void directoryAutoAdd_TH3I(void *p, TDirectory *dir) {
      ((::TH3I*)p)->DirectoryAutoAdd(dir);
   }
} // end of namespace ROOT for class ::TH3I

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_THLimitsFinder(void *p) {
      return  p ? new(p) ::THLimitsFinder : new ::THLimitsFinder;
   }
   static void *newArray_THLimitsFinder(Long_t nElements, void *p) {
      return p ? new(p) ::THLimitsFinder[nElements] : new ::THLimitsFinder[nElements];
   }
   // Wrapper around operator delete
   static void delete_THLimitsFinder(void *p) {
      delete ((::THLimitsFinder*)p);
   }
   static void deleteArray_THLimitsFinder(void *p) {
      delete [] ((::THLimitsFinder*)p);
   }
   static void destruct_THLimitsFinder(void *p) {
      typedef ::THLimitsFinder current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::THLimitsFinder

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

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

//______________________________________________________________________________
void THnSparse::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class THnSparse.
      TClass *R__cl = ::THnSparse::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNdimensions", &fNdimensions);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fChunkSize", &fChunkSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFilledBins", &fFilledBins);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAxes", &fAxes);
      R__insp.InspectMember(fAxes, "fAxes.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBinContent", &fBinContent);
      R__insp.InspectMember(fBinContent, "fBinContent.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBins", &fBins);
      R__insp.InspectMember(fBins, "fBins.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBinsContinued", &fBinsContinued);
      R__insp.InspectMember(fBinsContinued, "fBinsContinued.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEntries", &fEntries);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTsumw", &fTsumw);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTsumw2", &fTsumw2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTsumwx", &fTsumwx);
      R__insp.InspectMember(fTsumwx, "fTsumwx.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTsumwx2", &fTsumwx2);
      R__insp.InspectMember(fTsumwx2, "fTsumwx2.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCompactCoord", &fCompactCoord);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fIntegral", &fIntegral);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIntegralStatus", &fIntegralStatus);
      TNamed::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_THnSparse(void *p) {
      delete ((::THnSparse*)p);
   }
   static void deleteArray_THnSparse(void *p) {
      delete [] ((::THnSparse*)p);
   }
   static void destruct_THnSparse(void *p) {
      typedef ::THnSparse current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::THnSparse

//______________________________________________________________________________
template <> void THnSparseT<TArrayD>::Streamer(TBuffer &R__b)
{
   // Stream an object of class THnSparseT<TArrayD>.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(THnSparseT<TArrayD>::Class(),this);
   } else {
      R__b.WriteClassBuffer(THnSparseT<TArrayD>::Class(),this);
   }
}

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

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::THnSparseT<TArrayD>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      sobj->THnSparse::ShowMembers(R__insp);
   }

}

template <> void THnSparseT<TArrayD>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOT::THnSparseTlETArrayDgR_ShowMembers(this, R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_THnSparseTlETArrayDgR(void *p) {
      return  p ? new(p) ::THnSparseT<TArrayD> : new ::THnSparseT<TArrayD>;
   }
   static void *newArray_THnSparseTlETArrayDgR(Long_t nElements, void *p) {
      return p ? new(p) ::THnSparseT<TArrayD>[nElements] : new ::THnSparseT<TArrayD>[nElements];
   }
   // Wrapper around operator delete
   static void delete_THnSparseTlETArrayDgR(void *p) {
      delete ((::THnSparseT<TArrayD>*)p);
   }
   static void deleteArray_THnSparseTlETArrayDgR(void *p) {
      delete [] ((::THnSparseT<TArrayD>*)p);
   }
   static void destruct_THnSparseTlETArrayDgR(void *p) {
      typedef ::THnSparseT<TArrayD> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::THnSparseT<TArrayD>

//______________________________________________________________________________
template <> void THnSparseT<TArrayF>::Streamer(TBuffer &R__b)
{
   // Stream an object of class THnSparseT<TArrayF>.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(THnSparseT<TArrayF>::Class(),this);
   } else {
      R__b.WriteClassBuffer(THnSparseT<TArrayF>::Class(),this);
   }
}

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

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::THnSparseT<TArrayF>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      sobj->THnSparse::ShowMembers(R__insp);
   }

}

template <> void THnSparseT<TArrayF>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOT::THnSparseTlETArrayFgR_ShowMembers(this, R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_THnSparseTlETArrayFgR(void *p) {
      return  p ? new(p) ::THnSparseT<TArrayF> : new ::THnSparseT<TArrayF>;
   }
   static void *newArray_THnSparseTlETArrayFgR(Long_t nElements, void *p) {
      return p ? new(p) ::THnSparseT<TArrayF>[nElements] : new ::THnSparseT<TArrayF>[nElements];
   }
   // Wrapper around operator delete
   static void delete_THnSparseTlETArrayFgR(void *p) {
      delete ((::THnSparseT<TArrayF>*)p);
   }
   static void deleteArray_THnSparseTlETArrayFgR(void *p) {
      delete [] ((::THnSparseT<TArrayF>*)p);
   }
   static void destruct_THnSparseTlETArrayFgR(void *p) {
      typedef ::THnSparseT<TArrayF> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::THnSparseT<TArrayF>

//______________________________________________________________________________
template <> void THnSparseT<TArrayL>::Streamer(TBuffer &R__b)
{
   // Stream an object of class THnSparseT<TArrayL>.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(THnSparseT<TArrayL>::Class(),this);
   } else {
      R__b.WriteClassBuffer(THnSparseT<TArrayL>::Class(),this);
   }
}

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

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::THnSparseT<TArrayL>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      sobj->THnSparse::ShowMembers(R__insp);
   }

}

template <> void THnSparseT<TArrayL>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOT::THnSparseTlETArrayLgR_ShowMembers(this, R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_THnSparseTlETArrayLgR(void *p) {
      return  p ? new(p) ::THnSparseT<TArrayL> : new ::THnSparseT<TArrayL>;
   }
   static void *newArray_THnSparseTlETArrayLgR(Long_t nElements, void *p) {
      return p ? new(p) ::THnSparseT<TArrayL>[nElements] : new ::THnSparseT<TArrayL>[nElements];
   }
   // Wrapper around operator delete
   static void delete_THnSparseTlETArrayLgR(void *p) {
      delete ((::THnSparseT<TArrayL>*)p);
   }
   static void deleteArray_THnSparseTlETArrayLgR(void *p) {
      delete [] ((::THnSparseT<TArrayL>*)p);
   }
   static void destruct_THnSparseTlETArrayLgR(void *p) {
      typedef ::THnSparseT<TArrayL> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::THnSparseT<TArrayL>

//______________________________________________________________________________
template <> void THnSparseT<TArrayI>::Streamer(TBuffer &R__b)
{
   // Stream an object of class THnSparseT<TArrayI>.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(THnSparseT<TArrayI>::Class(),this);
   } else {
      R__b.WriteClassBuffer(THnSparseT<TArrayI>::Class(),this);
   }
}

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

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::THnSparseT<TArrayI>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      sobj->THnSparse::ShowMembers(R__insp);
   }

}

template <> void THnSparseT<TArrayI>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOT::THnSparseTlETArrayIgR_ShowMembers(this, R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_THnSparseTlETArrayIgR(void *p) {
      return  p ? new(p) ::THnSparseT<TArrayI> : new ::THnSparseT<TArrayI>;
   }
   static void *newArray_THnSparseTlETArrayIgR(Long_t nElements, void *p) {
      return p ? new(p) ::THnSparseT<TArrayI>[nElements] : new ::THnSparseT<TArrayI>[nElements];
   }
   // Wrapper around operator delete
   static void delete_THnSparseTlETArrayIgR(void *p) {
      delete ((::THnSparseT<TArrayI>*)p);
   }
   static void deleteArray_THnSparseTlETArrayIgR(void *p) {
      delete [] ((::THnSparseT<TArrayI>*)p);
   }
   static void destruct_THnSparseTlETArrayIgR(void *p) {
      typedef ::THnSparseT<TArrayI> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::THnSparseT<TArrayI>

//______________________________________________________________________________
template <> void THnSparseT<TArrayS>::Streamer(TBuffer &R__b)
{
   // Stream an object of class THnSparseT<TArrayS>.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(THnSparseT<TArrayS>::Class(),this);
   } else {
      R__b.WriteClassBuffer(THnSparseT<TArrayS>::Class(),this);
   }
}

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

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::THnSparseT<TArrayS>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      sobj->THnSparse::ShowMembers(R__insp);
   }

}

template <> void THnSparseT<TArrayS>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOT::THnSparseTlETArraySgR_ShowMembers(this, R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_THnSparseTlETArraySgR(void *p) {
      return  p ? new(p) ::THnSparseT<TArrayS> : new ::THnSparseT<TArrayS>;
   }
   static void *newArray_THnSparseTlETArraySgR(Long_t nElements, void *p) {
      return p ? new(p) ::THnSparseT<TArrayS>[nElements] : new ::THnSparseT<TArrayS>[nElements];
   }
   // Wrapper around operator delete
   static void delete_THnSparseTlETArraySgR(void *p) {
      delete ((::THnSparseT<TArrayS>*)p);
   }
   static void deleteArray_THnSparseTlETArraySgR(void *p) {
      delete [] ((::THnSparseT<TArrayS>*)p);
   }
   static void destruct_THnSparseTlETArraySgR(void *p) {
      typedef ::THnSparseT<TArrayS> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::THnSparseT<TArrayS>

//______________________________________________________________________________
template <> void THnSparseT<TArrayC>::Streamer(TBuffer &R__b)
{
   // Stream an object of class THnSparseT<TArrayC>.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(THnSparseT<TArrayC>::Class(),this);
   } else {
      R__b.WriteClassBuffer(THnSparseT<TArrayC>::Class(),this);
   }
}

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

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::THnSparseT<TArrayC>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      sobj->THnSparse::ShowMembers(R__insp);
   }

}

template <> void THnSparseT<TArrayC>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOT::THnSparseTlETArrayCgR_ShowMembers(this, R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_THnSparseTlETArrayCgR(void *p) {
      return  p ? new(p) ::THnSparseT<TArrayC> : new ::THnSparseT<TArrayC>;
   }
   static void *newArray_THnSparseTlETArrayCgR(Long_t nElements, void *p) {
      return p ? new(p) ::THnSparseT<TArrayC>[nElements] : new ::THnSparseT<TArrayC>[nElements];
   }
   // Wrapper around operator delete
   static void delete_THnSparseTlETArrayCgR(void *p) {
      delete ((::THnSparseT<TArrayC>*)p);
   }
   static void deleteArray_THnSparseTlETArrayCgR(void *p) {
      delete [] ((::THnSparseT<TArrayC>*)p);
   }
   static void destruct_THnSparseTlETArrayCgR(void *p) {
      typedef ::THnSparseT<TArrayC> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::THnSparseT<TArrayC>

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

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

//______________________________________________________________________________
void THnSparseArrayChunk::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class THnSparseArrayChunk.
      TClass *R__cl = ::THnSparseArrayChunk::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCoordinateAllocationSize", &fCoordinateAllocationSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSingleCoordinateSize", &fSingleCoordinateSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCoordinatesSize", &fCoordinatesSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCoordinates", &fCoordinates);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fContent", &fContent);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSumw2", &fSumw2);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_THnSparseArrayChunk(void *p) {
      return  p ? new(p) ::THnSparseArrayChunk : new ::THnSparseArrayChunk;
   }
   static void *newArray_THnSparseArrayChunk(Long_t nElements, void *p) {
      return p ? new(p) ::THnSparseArrayChunk[nElements] : new ::THnSparseArrayChunk[nElements];
   }
   // Wrapper around operator delete
   static void delete_THnSparseArrayChunk(void *p) {
      delete ((::THnSparseArrayChunk*)p);
   }
   static void deleteArray_THnSparseArrayChunk(void *p) {
      delete [] ((::THnSparseArrayChunk*)p);
   }
   static void destruct_THnSparseArrayChunk(void *p) {
      typedef ::THnSparseArrayChunk current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::THnSparseArrayChunk

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

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

//______________________________________________________________________________
void THStack::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class THStack.
      TClass *R__cl = ::THStack::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHists", &fHists);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStack", &fStack);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHistogram", &fHistogram);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaximum", &fMaximum);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinimum", &fMinimum);
      TNamed::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_THStack(void *p) {
      return  p ? new(p) ::THStack : new ::THStack;
   }
   static void *newArray_THStack(Long_t nElements, void *p) {
      return p ? new(p) ::THStack[nElements] : new ::THStack[nElements];
   }
   // Wrapper around operator delete
   static void delete_THStack(void *p) {
      delete ((::THStack*)p);
   }
   static void deleteArray_THStack(void *p) {
      delete [] ((::THStack*)p);
   }
   static void destruct_THStack(void *p) {
      typedef ::THStack current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::THStack

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TLimit(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TLimit : new ::TLimit;
   }
   static void *newArray_TLimit(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TLimit[nElements] : new ::TLimit[nElements];
   }
   // Wrapper around operator delete
   static void delete_TLimit(void *p) {
      delete ((::TLimit*)p);
   }
   static void deleteArray_TLimit(void *p) {
      delete [] ((::TLimit*)p);
   }
   static void destruct_TLimit(void *p) {
      typedef ::TLimit current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TLimit

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

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

//______________________________________________________________________________
void TLimitDataSource::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TLimitDataSource.
      TClass *R__cl = ::TLimitDataSource::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSignal", &fSignal);
      R__insp.InspectMember(fSignal, "fSignal.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBackground", &fBackground);
      R__insp.InspectMember(fBackground, "fBackground.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCandidates", &fCandidates);
      R__insp.InspectMember(fCandidates, "fCandidates.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fErrorOnSignal", &fErrorOnSignal);
      R__insp.InspectMember(fErrorOnSignal, "fErrorOnSignal.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fErrorOnBackground", &fErrorOnBackground);
      R__insp.InspectMember(fErrorOnBackground, "fErrorOnBackground.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIds", &fIds);
      R__insp.InspectMember(fIds, "fIds.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDummyTA", &fDummyTA);
      R__insp.InspectMember(fDummyTA, "fDummyTA.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDummyIds", &fDummyIds);
      R__insp.InspectMember(fDummyIds, "fDummyIds.");
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TLimitDataSource(void *p) {
      return  p ? new(p) ::TLimitDataSource : new ::TLimitDataSource;
   }
   static void *newArray_TLimitDataSource(Long_t nElements, void *p) {
      return p ? new(p) ::TLimitDataSource[nElements] : new ::TLimitDataSource[nElements];
   }
   // Wrapper around operator delete
   static void delete_TLimitDataSource(void *p) {
      delete ((::TLimitDataSource*)p);
   }
   static void deleteArray_TLimitDataSource(void *p) {
      delete [] ((::TLimitDataSource*)p);
   }
   static void destruct_TLimitDataSource(void *p) {
      typedef ::TLimitDataSource current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TLimitDataSource

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

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

//______________________________________________________________________________
void TConfidenceLevel::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TConfidenceLevel.
      TClass *R__cl = ::TConfidenceLevel::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNNMC", &fNNMC);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDtot", &fDtot);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStot", &fStot);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBtot", &fBtot);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTSD", &fTSD);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNMC", &fNMC);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMCL3S", &fMCL3S);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMCL5S", &fMCL5S);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTSB", &fTSB);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTSS", &fTSS);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLRS", &fLRS);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLRB", &fLRB);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fISS", &fISS);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fISB", &fISB);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TConfidenceLevel(void *p) {
      return  p ? new(p) ::TConfidenceLevel : new ::TConfidenceLevel;
   }
   static void *newArray_TConfidenceLevel(Long_t nElements, void *p) {
      return p ? new(p) ::TConfidenceLevel[nElements] : new ::TConfidenceLevel[nElements];
   }
   // Wrapper around operator delete
   static void delete_TConfidenceLevel(void *p) {
      delete ((::TConfidenceLevel*)p);
   }
   static void deleteArray_TConfidenceLevel(void *p) {
      delete [] ((::TConfidenceLevel*)p);
   }
   static void destruct_TConfidenceLevel(void *p) {
      typedef ::TConfidenceLevel current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TConfidenceLevel

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

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

//______________________________________________________________________________
void TMultiGraph::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMultiGraph.
      TClass *R__cl = ::TMultiGraph::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGraphs", &fGraphs);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFunctions", &fFunctions);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHistogram", &fHistogram);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaximum", &fMaximum);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinimum", &fMinimum);
      TNamed::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TMultiGraph(void *p) {
      return  p ? new(p) ::TMultiGraph : new ::TMultiGraph;
   }
   static void *newArray_TMultiGraph(Long_t nElements, void *p) {
      return p ? new(p) ::TMultiGraph[nElements] : new ::TMultiGraph[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMultiGraph(void *p) {
      delete ((::TMultiGraph*)p);
   }
   static void deleteArray_TMultiGraph(void *p) {
      delete [] ((::TMultiGraph*)p);
   }
   static void destruct_TMultiGraph(void *p) {
      typedef ::TMultiGraph current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TMultiGraph

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

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

//______________________________________________________________________________
void TMultiDimFit::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMultiDimFit.
      TClass *R__cl = ::TMultiDimFit::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fQuantity", &fQuantity);
      R__insp.InspectMember(fQuantity, "fQuantity.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSqError", &fSqError);
      R__insp.InspectMember(fSqError, "fSqError.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMeanQuantity", &fMeanQuantity);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxQuantity", &fMaxQuantity);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinQuantity", &fMinQuantity);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSumSqQuantity", &fSumSqQuantity);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSumSqAvgQuantity", &fSumSqAvgQuantity);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVariables", &fVariables);
      R__insp.InspectMember(fVariables, "fVariables.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNVariables", &fNVariables);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMeanVariables", &fMeanVariables);
      R__insp.InspectMember(fMeanVariables, "fMeanVariables.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxVariables", &fMaxVariables);
      R__insp.InspectMember(fMaxVariables, "fMaxVariables.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinVariables", &fMinVariables);
      R__insp.InspectMember(fMinVariables, "fMinVariables.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSampleSize", &fSampleSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTestQuantity", &fTestQuantity);
      R__insp.InspectMember(fTestQuantity, "fTestQuantity.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTestSqError", &fTestSqError);
      R__insp.InspectMember(fTestSqError, "fTestSqError.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTestVariables", &fTestVariables);
      R__insp.InspectMember(fTestVariables, "fTestVariables.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTestSampleSize", &fTestSampleSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinAngle", &fMinAngle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxAngle", &fMaxAngle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxTerms", &fMaxTerms);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinRelativeError", &fMinRelativeError);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMaxPowers", &fMaxPowers);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPowerLimit", &fPowerLimit);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFunctions", &fFunctions);
      R__insp.InspectMember(fFunctions, "fFunctions.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxFunctions", &fMaxFunctions);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFunctionCodes", &fFunctionCodes);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxStudy", &fMaxStudy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxFuncNV", &fMaxFuncNV);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOrthFunctions", &fOrthFunctions);
      R__insp.InspectMember(fOrthFunctions, "fOrthFunctions.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOrthFunctionNorms", &fOrthFunctionNorms);
      R__insp.InspectMember(fOrthFunctionNorms, "fOrthFunctionNorms.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMaxPowersFinal", &fMaxPowersFinal);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPowers", &fPowers);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPowerIndex", &fPowerIndex);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fResiduals", &fResiduals);
      R__insp.InspectMember(fResiduals, "fResiduals.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxResidual", &fMaxResidual);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinResidual", &fMinResidual);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxResidualRow", &fMaxResidualRow);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinResidualRow", &fMinResidualRow);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSumSqResidual", &fSumSqResidual);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNCoefficients", &fNCoefficients);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOrthCoefficients", &fOrthCoefficients);
      R__insp.InspectMember(fOrthCoefficients, "fOrthCoefficients.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOrthCurvatureMatrix", &fOrthCurvatureMatrix);
      R__insp.InspectMember(fOrthCurvatureMatrix, "fOrthCurvatureMatrix.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCoefficients", &fCoefficients);
      R__insp.InspectMember(fCoefficients, "fCoefficients.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCoefficientsRMS", &fCoefficientsRMS);
      R__insp.InspectMember(fCoefficientsRMS, "fCoefficientsRMS.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRMS", &fRMS);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fChi2", &fChi2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fParameterisationCode", &fParameterisationCode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fError", &fError);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTestError", &fTestError);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPrecision", &fPrecision);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTestPrecision", &fTestPrecision);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCorrelationCoeff", &fCorrelationCoeff);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCorrelationMatrix", &fCorrelationMatrix);
      R__insp.InspectMember(fCorrelationMatrix, "fCorrelationMatrix.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTestCorrelationCoeff", &fTestCorrelationCoeff);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHistograms", &fHistograms);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHistogramMask", &fHistogramMask);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBinVarX", &fBinVarX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBinVarY", &fBinVarY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFitter", &fFitter);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPolyType", &fPolyType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fShowCorrelation", &fShowCorrelation);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsUserFunction", &fIsUserFunction);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsVerbose", &fIsVerbose);
      TNamed::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TMultiDimFit(void *p) {
      return  p ? new(p) ::TMultiDimFit : new ::TMultiDimFit;
   }
   static void *newArray_TMultiDimFit(Long_t nElements, void *p) {
      return p ? new(p) ::TMultiDimFit[nElements] : new ::TMultiDimFit[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMultiDimFit(void *p) {
      delete ((::TMultiDimFit*)p);
   }
   static void deleteArray_TMultiDimFit(void *p) {
      delete [] ((::TMultiDimFit*)p);
   }
   static void destruct_TMultiDimFit(void *p) {
      typedef ::TMultiDimFit current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TMultiDimFit

//______________________________________________________________________________
void TPolyMarker::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TPolyMarker.
      TClass *R__cl = ::TPolyMarker::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fN", &fN);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLastPoint", &fLastPoint);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fX", &fX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fY", &fY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOption", &fOption);
      R__insp.InspectMember(fOption, "fOption.");
      TObject::ShowMembers(R__insp);
      TAttMarker::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TPolyMarker(void *p) {
      return  p ? new(p) ::TPolyMarker : new ::TPolyMarker;
   }
   static void *newArray_TPolyMarker(Long_t nElements, void *p) {
      return p ? new(p) ::TPolyMarker[nElements] : new ::TPolyMarker[nElements];
   }
   // Wrapper around operator delete
   static void delete_TPolyMarker(void *p) {
      delete ((::TPolyMarker*)p);
   }
   static void deleteArray_TPolyMarker(void *p) {
      delete [] ((::TPolyMarker*)p);
   }
   static void destruct_TPolyMarker(void *p) {
      typedef ::TPolyMarker current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TPolyMarker(TBuffer &buf, void *obj) {
      ((::TPolyMarker*)obj)->::TPolyMarker::Streamer(buf);
   }
} // end of namespace ROOT for class ::TPolyMarker

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

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

//______________________________________________________________________________
void TPrincipal::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TPrincipal.
      TClass *R__cl = ::TPrincipal::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNumberOfDataPoints", &fNumberOfDataPoints);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNumberOfVariables", &fNumberOfVariables);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMeanValues", &fMeanValues);
      R__insp.InspectMember(fMeanValues, "fMeanValues.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSigmas", &fSigmas);
      R__insp.InspectMember(fSigmas, "fSigmas.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCovarianceMatrix", &fCovarianceMatrix);
      R__insp.InspectMember(fCovarianceMatrix, "fCovarianceMatrix.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEigenVectors", &fEigenVectors);
      R__insp.InspectMember(fEigenVectors, "fEigenVectors.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEigenValues", &fEigenValues);
      R__insp.InspectMember(fEigenValues, "fEigenValues.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOffDiagonal", &fOffDiagonal);
      R__insp.InspectMember(fOffDiagonal, "fOffDiagonal.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUserData", &fUserData);
      R__insp.InspectMember(fUserData, "fUserData.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTrace", &fTrace);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHistograms", &fHistograms);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsNormalised", &fIsNormalised);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStoreData", &fStoreData);
      TNamed::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TPrincipal(void *p) {
      return  p ? new(p) ::TPrincipal : new ::TPrincipal;
   }
   static void *newArray_TPrincipal(Long_t nElements, void *p) {
      return p ? new(p) ::TPrincipal[nElements] : new ::TPrincipal[nElements];
   }
   // Wrapper around operator delete
   static void delete_TPrincipal(void *p) {
      delete ((::TPrincipal*)p);
   }
   static void deleteArray_TPrincipal(void *p) {
      delete [] ((::TPrincipal*)p);
   }
   static void destruct_TPrincipal(void *p) {
      typedef ::TPrincipal current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TPrincipal

//______________________________________________________________________________
void TProfile::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TProfile.
      TClass *R__cl = ::TProfile::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBinEntries", &fBinEntries);
      R__insp.InspectMember(fBinEntries, "fBinEntries.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fErrorMode", &fErrorMode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fYmin", &fYmin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fYmax", &fYmax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fScaling", &fScaling);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTsumwy", &fTsumwy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTsumwy2", &fTsumwy2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBinSumw2", &fBinSumw2);
      R__insp.InspectMember(fBinSumw2, "fBinSumw2.");
      TH1D::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TProfile(void *p) {
      return  p ? new(p) ::TProfile : new ::TProfile;
   }
   static void *newArray_TProfile(Long_t nElements, void *p) {
      return p ? new(p) ::TProfile[nElements] : new ::TProfile[nElements];
   }
   // Wrapper around operator delete
   static void delete_TProfile(void *p) {
      delete ((::TProfile*)p);
   }
   static void deleteArray_TProfile(void *p) {
      delete [] ((::TProfile*)p);
   }
   static void destruct_TProfile(void *p) {
      typedef ::TProfile current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around the directory auto add.
   static void directoryAutoAdd_TProfile(void *p, TDirectory *dir) {
      ((::TProfile*)p)->DirectoryAutoAdd(dir);
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TProfile(TBuffer &buf, void *obj) {
      ((::TProfile*)obj)->::TProfile::Streamer(buf);
   }
} // end of namespace ROOT for class ::TProfile

//______________________________________________________________________________
void TProfile2D::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TProfile2D.
      TClass *R__cl = ::TProfile2D::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBinEntries", &fBinEntries);
      R__insp.InspectMember(fBinEntries, "fBinEntries.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fErrorMode", &fErrorMode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fZmin", &fZmin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fZmax", &fZmax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fScaling", &fScaling);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTsumwz", &fTsumwz);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTsumwz2", &fTsumwz2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBinSumw2", &fBinSumw2);
      R__insp.InspectMember(fBinSumw2, "fBinSumw2.");
      TH2D::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TProfile2D(void *p) {
      return  p ? new(p) ::TProfile2D : new ::TProfile2D;
   }
   static void *newArray_TProfile2D(Long_t nElements, void *p) {
      return p ? new(p) ::TProfile2D[nElements] : new ::TProfile2D[nElements];
   }
   // Wrapper around operator delete
   static void delete_TProfile2D(void *p) {
      delete ((::TProfile2D*)p);
   }
   static void deleteArray_TProfile2D(void *p) {
      delete [] ((::TProfile2D*)p);
   }
   static void destruct_TProfile2D(void *p) {
      typedef ::TProfile2D current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around the directory auto add.
   static void directoryAutoAdd_TProfile2D(void *p, TDirectory *dir) {
      ((::TProfile2D*)p)->DirectoryAutoAdd(dir);
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TProfile2D(TBuffer &buf, void *obj) {
      ((::TProfile2D*)obj)->::TProfile2D::Streamer(buf);
   }
} // end of namespace ROOT for class ::TProfile2D

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

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

//______________________________________________________________________________
void TProfile3D::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TProfile3D.
      TClass *R__cl = ::TProfile3D::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBinEntries", &fBinEntries);
      R__insp.InspectMember(fBinEntries, "fBinEntries.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fErrorMode", &fErrorMode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTmin", &fTmin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTmax", &fTmax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fScaling", &fScaling);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTsumwt", &fTsumwt);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTsumwt2", &fTsumwt2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBinSumw2", &fBinSumw2);
      R__insp.InspectMember(fBinSumw2, "fBinSumw2.");
      TH3D::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TProfile3D(void *p) {
      return  p ? new(p) ::TProfile3D : new ::TProfile3D;
   }
   static void *newArray_TProfile3D(Long_t nElements, void *p) {
      return p ? new(p) ::TProfile3D[nElements] : new ::TProfile3D[nElements];
   }
   // Wrapper around operator delete
   static void delete_TProfile3D(void *p) {
      delete ((::TProfile3D*)p);
   }
   static void deleteArray_TProfile3D(void *p) {
      delete [] ((::TProfile3D*)p);
   }
   static void destruct_TProfile3D(void *p) {
      typedef ::TProfile3D current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around the directory auto add.
   static void directoryAutoAdd_TProfile3D(void *p, TDirectory *dir) {
      ((::TProfile3D*)p)->DirectoryAutoAdd(dir);
   }
} // end of namespace ROOT for class ::TProfile3D

//______________________________________________________________________________
void TSpline::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TSpline.
      TClass *R__cl = ::TSpline::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDelta", &fDelta);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXmin", &fXmin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXmax", &fXmax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNp", &fNp);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fKstep", &fKstep);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHistogram", &fHistogram);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGraph", &fGraph);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNpx", &fNpx);
      TNamed::ShowMembers(R__insp);
      TAttLine::ShowMembers(R__insp);
      TAttFill::ShowMembers(R__insp);
      TAttMarker::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TSpline(void *p) {
      delete ((::TSpline*)p);
   }
   static void deleteArray_TSpline(void *p) {
      delete [] ((::TSpline*)p);
   }
   static void destruct_TSpline(void *p) {
      typedef ::TSpline current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TSpline(TBuffer &buf, void *obj) {
      ((::TSpline*)obj)->::TSpline::Streamer(buf);
   }
} // end of namespace ROOT for class ::TSpline

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TSpline5(void *p) {
      return  p ? new(p) ::TSpline5 : new ::TSpline5;
   }
   static void *newArray_TSpline5(Long_t nElements, void *p) {
      return p ? new(p) ::TSpline5[nElements] : new ::TSpline5[nElements];
   }
   // Wrapper around operator delete
   static void delete_TSpline5(void *p) {
      delete ((::TSpline5*)p);
   }
   static void deleteArray_TSpline5(void *p) {
      delete [] ((::TSpline5*)p);
   }
   static void destruct_TSpline5(void *p) {
      typedef ::TSpline5 current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TSpline5(TBuffer &buf, void *obj) {
      ((::TSpline5*)obj)->::TSpline5::Streamer(buf);
   }
} // end of namespace ROOT for class ::TSpline5

//______________________________________________________________________________
void TSpline3::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TSpline3.
      TClass *R__cl = ::TSpline3::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPoly", &fPoly);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fValBeg", &fValBeg);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fValEnd", &fValEnd);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBegCond", &fBegCond);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEndCond", &fEndCond);
      TSpline::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TSpline3(void *p) {
      return  p ? new(p) ::TSpline3 : new ::TSpline3;
   }
   static void *newArray_TSpline3(Long_t nElements, void *p) {
      return p ? new(p) ::TSpline3[nElements] : new ::TSpline3[nElements];
   }
   // Wrapper around operator delete
   static void delete_TSpline3(void *p) {
      delete ((::TSpline3*)p);
   }
   static void deleteArray_TSpline3(void *p) {
      delete [] ((::TSpline3*)p);
   }
   static void destruct_TSpline3(void *p) {
      typedef ::TSpline3 current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TSpline3(TBuffer &buf, void *obj) {
      ((::TSpline3*)obj)->::TSpline3::Streamer(buf);
   }
} // end of namespace ROOT for class ::TSpline3

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

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

//______________________________________________________________________________
void TSplinePoly::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TSplinePoly.
      TClass *R__cl = ::TSplinePoly::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fX", &fX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fY", &fY);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TSplinePoly(void *p) {
      return  p ? new(p) ::TSplinePoly : new ::TSplinePoly;
   }
   static void *newArray_TSplinePoly(Long_t nElements, void *p) {
      return p ? new(p) ::TSplinePoly[nElements] : new ::TSplinePoly[nElements];
   }
   // Wrapper around operator delete
   static void delete_TSplinePoly(void *p) {
      delete ((::TSplinePoly*)p);
   }
   static void deleteArray_TSplinePoly(void *p) {
      delete [] ((::TSplinePoly*)p);
   }
   static void destruct_TSplinePoly(void *p) {
      typedef ::TSplinePoly current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TSplinePoly

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

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

//______________________________________________________________________________
void TSplinePoly5::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TSplinePoly5.
      TClass *R__cl = ::TSplinePoly5::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fB", &fB);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fC", &fC);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fD", &fD);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fE", &fE);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fF", &fF);
      TSplinePoly::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TSplinePoly5(void *p) {
      return  p ? new(p) ::TSplinePoly5 : new ::TSplinePoly5;
   }
   static void *newArray_TSplinePoly5(Long_t nElements, void *p) {
      return p ? new(p) ::TSplinePoly5[nElements] : new ::TSplinePoly5[nElements];
   }
   // Wrapper around operator delete
   static void delete_TSplinePoly5(void *p) {
      delete ((::TSplinePoly5*)p);
   }
   static void deleteArray_TSplinePoly5(void *p) {
      delete [] ((::TSplinePoly5*)p);
   }
   static void destruct_TSplinePoly5(void *p) {
      typedef ::TSplinePoly5 current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TSplinePoly5

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

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

//______________________________________________________________________________
void TSplinePoly3::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TSplinePoly3.
      TClass *R__cl = ::TSplinePoly3::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fB", &fB);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fC", &fC);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fD", &fD);
      TSplinePoly::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TSplinePoly3(void *p) {
      return  p ? new(p) ::TSplinePoly3 : new ::TSplinePoly3;
   }
   static void *newArray_TSplinePoly3(Long_t nElements, void *p) {
      return p ? new(p) ::TSplinePoly3[nElements] : new ::TSplinePoly3[nElements];
   }
   // Wrapper around operator delete
   static void delete_TSplinePoly3(void *p) {
      delete ((::TSplinePoly3*)p);
   }
   static void deleteArray_TSplinePoly3(void *p) {
      delete [] ((::TSplinePoly3*)p);
   }
   static void destruct_TSplinePoly3(void *p) {
      typedef ::TSplinePoly3 current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TSplinePoly3

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

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

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

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TVirtualHistPainter(void *p) {
      delete ((::TVirtualHistPainter*)p);
   }
   static void deleteArray_TVirtualHistPainter(void *p) {
      delete [] ((::TVirtualHistPainter*)p);
   }
   static void destruct_TVirtualHistPainter(void *p) {
      typedef ::TVirtualHistPainter current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TVirtualHistPainter

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

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

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

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TVirtualGraphPainter(void *p) {
      delete ((::TVirtualGraphPainter*)p);
   }
   static void deleteArray_TVirtualGraphPainter(void *p) {
      delete [] ((::TVirtualGraphPainter*)p);
   }
   static void destruct_TVirtualGraphPainter(void *p) {
      typedef ::TVirtualGraphPainter current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TVirtualGraphPainter

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

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

//______________________________________________________________________________
void TBackCompFitter::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TBackCompFitter.
      TClass *R__cl = ::TBackCompFitter::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFitData", (void*)&fFitData);
      R__insp.InspectMember("auto_ptr<ROOT::Fit::FitData>", (void*)&fFitData, "fFitData.", true);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFitter", (void*)&fFitter);
      R__insp.InspectMember("auto_ptr<ROOT::Fit::Fitter>", (void*)&fFitter, "fFitter.", true);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMinimizer", &fMinimizer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fObjFunc", &fObjFunc);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fModelFunc", &fModelFunc);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCovar", (void*)&fCovar);
      R__insp.InspectMember("vector<double>", (void*)&fCovar, "fCovar.", false);
      TVirtualFitter::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TBackCompFitter(void *p) {
      return  p ? new(p) ::TBackCompFitter : new ::TBackCompFitter;
   }
   static void *newArray_TBackCompFitter(Long_t nElements, void *p) {
      return p ? new(p) ::TBackCompFitter[nElements] : new ::TBackCompFitter[nElements];
   }
   // Wrapper around operator delete
   static void delete_TBackCompFitter(void *p) {
      delete ((::TBackCompFitter*)p);
   }
   static void deleteArray_TBackCompFitter(void *p) {
      delete [] ((::TBackCompFitter*)p);
   }
   static void destruct_TBackCompFitter(void *p) {
      typedef ::TBackCompFitter current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TBackCompFitter

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

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

//______________________________________________________________________________
void TUnfold::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TUnfold.
      TClass *R__cl = ::TUnfold::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fA", &fA);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLsquared", &fLsquared);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fVyy", &fVyy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fY", &fY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fX0", &fX0);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTauSquared", &fTauSquared);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBiasScale", &fBiasScale);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXToHist", &fXToHist);
      R__insp.InspectMember(fXToHist, "fXToHist.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHistToX", &fHistToX);
      R__insp.InspectMember(fHistToX, "fHistToX.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSumOverY", &fSumOverY);
      R__insp.InspectMember(fSumOverY, "fSumOverY.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fConstraint", &fConstraint);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRegMode", &fRegMode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fX", &fX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fVxx", &fVxx);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fVxxInv", &fVxxInv);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAx", &fAx);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fChi2A", &fChi2A);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLXsquared", &fLXsquared);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRhoMax", &fRhoMax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRhoAvg", &fRhoAvg);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNdf", &fNdf);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDXDAM[2]", &fDXDAM);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDXDAZ[2]", &fDXDAZ);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDXDtauSquared", &fDXDtauSquared);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDXDY", &fDXDY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEinv", &fEinv);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fE", &fE);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TUnfold(void *p) {
      delete ((::TUnfold*)p);
   }
   static void deleteArray_TUnfold(void *p) {
      delete [] ((::TUnfold*)p);
   }
   static void destruct_TUnfold(void *p) {
      typedef ::TUnfold current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TUnfold

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

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

//______________________________________________________________________________
void TUnfoldSys::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TUnfoldSys.
      TClass *R__cl = ::TUnfoldSys::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDAinRelSq", &fDAinRelSq);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDAinColRelSq", &fDAinColRelSq);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAoutside", &fAoutside);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSysIn", &fSysIn);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBgrIn", &fBgrIn);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBgrErrUncorrIn", &fBgrErrUncorrIn);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBgrErrCorrIn", &fBgrErrCorrIn);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDtau", &fDtau);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fYData", &fYData);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fVyyData", &fVyyData);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEmatUncorrX", &fEmatUncorrX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEmatUncorrAx", &fEmatUncorrAx);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDeltaCorrX", &fDeltaCorrX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDeltaCorrAx", &fDeltaCorrAx);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDeltaSysTau", &fDeltaSysTau);
      TUnfold::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TUnfoldSys(void *p) {
      delete ((::TUnfoldSys*)p);
   }
   static void deleteArray_TUnfoldSys(void *p) {
      delete [] ((::TUnfoldSys*)p);
   }
   static void destruct_TUnfoldSys(void *p) {
      typedef ::TUnfoldSys current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TUnfoldSys

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

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

//______________________________________________________________________________
void TSVDUnfold::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TSVDUnfold.
      TClass *R__cl = ::TSVDUnfold::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNdim", &fNdim);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDdim", &fDdim);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNormalize", &fNormalize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fKReg", &fKReg);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDHist", &fDHist);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSVHist", &fSVHist);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBdat", &fBdat);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBini", &fBini);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fXini", &fXini);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAdet", &fAdet);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fToyhisto", &fToyhisto);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fToymat", &fToymat);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fToyMode", &fToyMode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMatToyMode", &fMatToyMode);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TSVDUnfold(void *p) {
      delete ((::TSVDUnfold*)p);
   }
   static void deleteArray_TSVDUnfold(void *p) {
      delete [] ((::TSVDUnfold*)p);
   }
   static void destruct_TSVDUnfold(void *p) {
      typedef ::TSVDUnfold current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TSVDUnfold

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

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

//______________________________________________________________________________
void TEfficiency::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEfficiency.
      TClass *R__cl = ::TEfficiency::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBeta_alpha", &fBeta_alpha);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBeta_beta", &fBeta_beta);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBeta_bin_params", (void*)&fBeta_bin_params);
      R__insp.InspectMember("vector<std::pair<Double_t,Double_t> >", (void*)&fBeta_bin_params, "fBeta_bin_params.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBoundary", &fBoundary);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fConfLevel", &fConfLevel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDirectory", &fDirectory);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFunctions", &fFunctions);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPaintGraph", &fPaintGraph);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPaintHisto", &fPaintHisto);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPassedHistogram", &fPassedHistogram);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStatisticOption", &fStatisticOption);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTotalHistogram", &fTotalHistogram);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWeight", &fWeight);
      TNamed::ShowMembers(R__insp);
      TAttLine::ShowMembers(R__insp);
      TAttFill::ShowMembers(R__insp);
      TAttMarker::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEfficiency(void *p) {
      return  p ? new(p) ::TEfficiency : new ::TEfficiency;
   }
   static void *newArray_TEfficiency(Long_t nElements, void *p) {
      return p ? new(p) ::TEfficiency[nElements] : new ::TEfficiency[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEfficiency(void *p) {
      delete ((::TEfficiency*)p);
   }
   static void deleteArray_TEfficiency(void *p) {
      delete [] ((::TEfficiency*)p);
   }
   static void destruct_TEfficiency(void *p) {
      typedef ::TEfficiency current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEfficiency

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

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

//______________________________________________________________________________
void TKDE::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TKDE.
      TClass *R__cl = ::TKDE::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fKernelFunction", &fKernelFunction);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fKernel", &fKernel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fData", (void*)&fData);
      R__insp.InspectMember("vector<Double_t>", (void*)&fData, "fData.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEvents", (void*)&fEvents);
      R__insp.InspectMember("vector<Double_t>", (void*)&fEvents, "fEvents.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPDF", &fPDF);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUpperPDF", &fUpperPDF);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLowerPDF", &fLowerPDF);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fApproximateBias", &fApproximateBias);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGraph", &fGraph);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fKernelType", &fKernelType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIteration", &fIteration);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMirror", &fMirror);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBinning", &fBinning);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUseMirroring", &fUseMirroring);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMirrorLeft", &fMirrorLeft);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMirrorRight", &fMirrorRight);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAsymLeft", &fAsymLeft);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAsymRight", &fAsymRight);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUseBins", &fUseBins);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNewData", &fNewData);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUseMinMaxFromData", &fUseMinMaxFromData);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNBins", &fNBins);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNEvents", &fNEvents);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUseBinsNEvents", &fUseBinsNEvents);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMean", &fMean);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSigma", &fSigma);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSigmaRob", &fSigmaRob);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXMin", &fXMin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXMax", &fXMax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRho", &fRho);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAdaptiveBandwidthFactor", &fAdaptiveBandwidthFactor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWeightSize", &fWeightSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCanonicalBandwidths", (void*)&fCanonicalBandwidths);
      R__insp.InspectMember("vector<Double_t>", (void*)&fCanonicalBandwidths, "fCanonicalBandwidths.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fKernelSigmas2", (void*)&fKernelSigmas2);
      R__insp.InspectMember("vector<Double_t>", (void*)&fKernelSigmas2, "fKernelSigmas2.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBinCount", (void*)&fBinCount);
      R__insp.InspectMember("vector<UInt_t>", (void*)&fBinCount, "fBinCount.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSettedOptions", (void*)&fSettedOptions);
      R__insp.InspectMember("vector<Bool_t>", (void*)&fSettedOptions, "fSettedOptions.", false);
      TNamed::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TKDE(void *p) {
      return  p ? new(p) ::TKDE : new ::TKDE;
   }
   static void *newArray_TKDE(Long_t nElements, void *p) {
      return p ? new(p) ::TKDE[nElements] : new ::TKDE[nElements];
   }
   // Wrapper around operator delete
   static void delete_TKDE(void *p) {
      delete ((::TKDE*)p);
   }
   static void deleteArray_TKDE(void *p) {
      delete [] ((::TKDE*)p);
   }
   static void destruct_TKDE(void *p) {
      typedef ::TKDE current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TKDE

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLWrappedTF1(void *p) {
      delete ((::ROOT::Math::WrappedTF1*)p);
   }
   static void deleteArray_ROOTcLcLMathcLcLWrappedTF1(void *p) {
      delete [] ((::ROOT::Math::WrappedTF1*)p);
   }
   static void destruct_ROOTcLcLMathcLcLWrappedTF1(void *p) {
      typedef ::ROOT::Math::WrappedTF1 current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::WrappedTF1

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLWrappedMultiTF1(void *p) {
      delete ((::ROOT::Math::WrappedMultiTF1*)p);
   }
   static void deleteArray_ROOTcLcLMathcLcLWrappedMultiTF1(void *p) {
      delete [] ((::ROOT::Math::WrappedMultiTF1*)p);
   }
   static void destruct_ROOTcLcLMathcLcLWrappedMultiTF1(void *p) {
      typedef ::ROOT::Math::WrappedMultiTF1 current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::WrappedMultiTF1

namespace ROOT {
   void vectorlEboolgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlEboolgR_Dictionary();
   static void *new_vectorlEboolgR(void *p = 0);
   static void *newArray_vectorlEboolgR(Long_t size, void *p);
   static void delete_vectorlEboolgR(void *p);
   static void deleteArray_vectorlEboolgR(void *p);
   static void destruct_vectorlEboolgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<bool>*)
   {
      vector<bool> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<bool>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<bool>", -2, "prec_stl/vector", 49,
                  typeid(vector<bool>), DefineBehavior(ptr, ptr),
                  0, &vectorlEboolgR_Dictionary, isa_proxy, 0,
                  sizeof(vector<bool>) );
      instance.SetNew(&new_vectorlEboolgR);
      instance.SetNewArray(&newArray_vectorlEboolgR);
      instance.SetDelete(&delete_vectorlEboolgR);
      instance.SetDeleteArray(&deleteArray_vectorlEboolgR);
      instance.SetDestructor(&destruct_vectorlEboolgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<bool> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<bool>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEboolgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<bool> : new vector<bool>;
   }
   static void *newArray_vectorlEboolgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<bool>[nElements] : new vector<bool>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEboolgR(void *p) {
      delete ((vector<bool>*)p);
   }
   static void deleteArray_vectorlEboolgR(void *p) {
      delete [] ((vector<bool>*)p);
   }
   static void destruct_vectorlEboolgR(void *p) {
      typedef vector<bool> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<bool>

namespace ROOT {
   void vectorlEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlEdoublegR_Dictionary();
   static void *new_vectorlEdoublegR(void *p = 0);
   static void *newArray_vectorlEdoublegR(Long_t size, void *p);
   static void delete_vectorlEdoublegR(void *p);
   static void deleteArray_vectorlEdoublegR(void *p);
   static void destruct_vectorlEdoublegR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<double>*)
   {
      vector<double> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<double>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<double>", -2, "prec_stl/vector", 49,
                  typeid(vector<double>), DefineBehavior(ptr, ptr),
                  0, &vectorlEdoublegR_Dictionary, isa_proxy, 0,
                  sizeof(vector<double>) );
      instance.SetNew(&new_vectorlEdoublegR);
      instance.SetNewArray(&newArray_vectorlEdoublegR);
      instance.SetDelete(&delete_vectorlEdoublegR);
      instance.SetDeleteArray(&deleteArray_vectorlEdoublegR);
      instance.SetDestructor(&destruct_vectorlEdoublegR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<double> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<double>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEdoublegR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<double> : new vector<double>;
   }
   static void *newArray_vectorlEdoublegR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<double>[nElements] : new vector<double>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEdoublegR(void *p) {
      delete ((vector<double>*)p);
   }
   static void deleteArray_vectorlEdoublegR(void *p) {
      delete [] ((vector<double>*)p);
   }
   static void destruct_vectorlEdoublegR(void *p) {
      typedef vector<double> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<double>

namespace ROOT {
   void vectorlEpairlEdoublecOdoublegRsPgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlEpairlEdoublecOdoublegRsPgR_Dictionary();
   static void *new_vectorlEpairlEdoublecOdoublegRsPgR(void *p = 0);
   static void *newArray_vectorlEpairlEdoublecOdoublegRsPgR(Long_t size, void *p);
   static void delete_vectorlEpairlEdoublecOdoublegRsPgR(void *p);
   static void deleteArray_vectorlEpairlEdoublecOdoublegRsPgR(void *p);
   static void destruct_vectorlEpairlEdoublecOdoublegRsPgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<pair<double,double> >*)
   {
      vector<pair<double,double> > *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<pair<double,double> >),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<pair<double,double> >", -2, "prec_stl/vector", 49,
                  typeid(vector<pair<double,double> >), DefineBehavior(ptr, ptr),
                  0, &vectorlEpairlEdoublecOdoublegRsPgR_Dictionary, isa_proxy, 0,
                  sizeof(vector<pair<double,double> >) );
      instance.SetNew(&new_vectorlEpairlEdoublecOdoublegRsPgR);
      instance.SetNewArray(&newArray_vectorlEpairlEdoublecOdoublegRsPgR);
      instance.SetDelete(&delete_vectorlEpairlEdoublecOdoublegRsPgR);
      instance.SetDeleteArray(&deleteArray_vectorlEpairlEdoublecOdoublegRsPgR);
      instance.SetDestructor(&destruct_vectorlEpairlEdoublecOdoublegRsPgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<pair<double,double> > >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<pair<double,double> >*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEpairlEdoublecOdoublegRsPgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<pair<double,double> > : new vector<pair<double,double> >;
   }
   static void *newArray_vectorlEpairlEdoublecOdoublegRsPgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<pair<double,double> >[nElements] : new vector<pair<double,double> >[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEpairlEdoublecOdoublegRsPgR(void *p) {
      delete ((vector<pair<double,double> >*)p);
   }
   static void deleteArray_vectorlEpairlEdoublecOdoublegRsPgR(void *p) {
      delete [] ((vector<pair<double,double> >*)p);
   }
   static void destruct_vectorlEpairlEdoublecOdoublegRsPgR(void *p) {
      typedef vector<pair<double,double> > current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<pair<double,double> >

namespace ROOT {
   void vectorlEunsignedsPintgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlEunsignedsPintgR_Dictionary();
   static void *new_vectorlEunsignedsPintgR(void *p = 0);
   static void *newArray_vectorlEunsignedsPintgR(Long_t size, void *p);
   static void delete_vectorlEunsignedsPintgR(void *p);
   static void deleteArray_vectorlEunsignedsPintgR(void *p);
   static void destruct_vectorlEunsignedsPintgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<unsigned int>*)
   {
      vector<unsigned int> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<unsigned int>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<unsigned int>", -2, "prec_stl/vector", 49,
                  typeid(vector<unsigned int>), DefineBehavior(ptr, ptr),
                  0, &vectorlEunsignedsPintgR_Dictionary, isa_proxy, 0,
                  sizeof(vector<unsigned int>) );
      instance.SetNew(&new_vectorlEunsignedsPintgR);
      instance.SetNewArray(&newArray_vectorlEunsignedsPintgR);
      instance.SetDelete(&delete_vectorlEunsignedsPintgR);
      instance.SetDeleteArray(&deleteArray_vectorlEunsignedsPintgR);
      instance.SetDestructor(&destruct_vectorlEunsignedsPintgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<unsigned int> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<unsigned int>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEunsignedsPintgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<unsigned int> : new vector<unsigned int>;
   }
   static void *newArray_vectorlEunsignedsPintgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<unsigned int>[nElements] : new vector<unsigned int>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEunsignedsPintgR(void *p) {
      delete ((vector<unsigned int>*)p);
   }
   static void deleteArray_vectorlEunsignedsPintgR(void *p) {
      delete [] ((vector<unsigned int>*)p);
   }
   static void destruct_vectorlEunsignedsPintgR(void *p) {
      typedef vector<unsigned int> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<unsigned int>

/********************************************************
* hist/hist/src/G__Hist.cxx
* CAUTION: DON'T CHANGE THIS FILE. THIS FILE IS AUTOMATICALLY GENERATED
*          FROM HEADER FILES LISTED IN G__setup_cpp_environmentXXX().
*          CHANGE THOSE HEADER FILES AND REGENERATE THIS FILE.
********************************************************/

#ifdef G__MEMTEST
#undef malloc
#undef free
#endif

#if defined(__GNUC__) && __GNUC__ >= 4 && ((__GNUC_MINOR__ == 2 && __GNUC_PATCHLEVEL__ >= 1) || (__GNUC_MINOR__ >= 3))
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif

extern "C" void G__cpp_reset_tagtableG__Hist();

extern "C" void G__set_cpp_environmentG__Hist() {
  G__add_compiledheader("TObject.h");
  G__add_compiledheader("TMemberInspector.h");
  G__add_compiledheader("Foption.h");
  G__add_compiledheader("HFitInterface.h");
  G__add_compiledheader("TAxis.h");
  G__add_compiledheader("TBackCompFitter.h");
  G__add_compiledheader("TBinomialEfficiencyFitter.h");
  G__add_compiledheader("TConfidenceLevel.h");
  G__add_compiledheader("TEfficiency.h");
  G__add_compiledheader("TF12.h");
  G__add_compiledheader("TF1.h");
  G__add_compiledheader("TF2.h");
  G__add_compiledheader("TF3.h");
  G__add_compiledheader("TFitResult.h");
  G__add_compiledheader("TFitResultPtr.h");
  G__add_compiledheader("TFormula.h");
  G__add_compiledheader("TFormulaPrimitive.h");
  G__add_compiledheader("TFractionFitter.h");
  G__add_compiledheader("TGraph2DErrors.h");
  G__add_compiledheader("TGraph2D.h");
  G__add_compiledheader("TGraphAsymmErrors.h");
  G__add_compiledheader("TGraphBentErrors.h");
  G__add_compiledheader("TGraphDelaunay.h");
  G__add_compiledheader("TGraphErrors.h");
  G__add_compiledheader("TGraph.h");
  G__add_compiledheader("TGraphSmooth.h");
  G__add_compiledheader("TGraphTime.h");
  G__add_compiledheader("TH1C.h");
  G__add_compiledheader("TH1D.h");
  G__add_compiledheader("TH1F.h");
  G__add_compiledheader("TH1.h");
  G__add_compiledheader("TH1I.h");
  G__add_compiledheader("TH1K.h");
  G__add_compiledheader("TH1S.h");
  G__add_compiledheader("TH2C.h");
  G__add_compiledheader("TH2D.h");
  G__add_compiledheader("TH2F.h");
  G__add_compiledheader("TH2.h");
  G__add_compiledheader("TH2I.h");
  G__add_compiledheader("TH2Poly.h");
  G__add_compiledheader("TH2S.h");
  G__add_compiledheader("TH3C.h");
  G__add_compiledheader("TH3D.h");
  G__add_compiledheader("TH3F.h");
  G__add_compiledheader("TH3.h");
  G__add_compiledheader("TH3I.h");
  G__add_compiledheader("TH3S.h");
  G__add_compiledheader("THLimitsFinder.h");
  G__add_compiledheader("THnSparse.h");
  G__add_compiledheader("THStack.h");
  G__add_compiledheader("TKDE.h");
  G__add_compiledheader("TLimitDataSource.h");
  G__add_compiledheader("TLimit.h");
  G__add_compiledheader("TMultiDimFit.h");
  G__add_compiledheader("TMultiGraph.h");
  G__add_compiledheader("TPolyMarker.h");
  G__add_compiledheader("TPrincipal.h");
  G__add_compiledheader("TProfile2D.h");
  G__add_compiledheader("TProfile3D.h");
  G__add_compiledheader("TProfile.h");
  G__add_compiledheader("TSpline.h");
  G__add_compiledheader("TSVDUnfold.h");
  G__add_compiledheader("TUnfold.h");
  G__add_compiledheader("TUnfoldSys.h");
  G__add_compiledheader("TVirtualGraphPainter.h");
  G__add_compiledheader("TVirtualHistPainter.h");
  G__add_compiledheader("Math/WrappedMultiTF1.h");
  G__add_compiledheader("Math/WrappedTF1.h");
  G__cpp_reset_tagtableG__Hist();
}
#include <new>
extern "C" int G__cpp_dllrevG__Hist() { return(30051515); }

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

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

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

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

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

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


/* TH1 */
static int G__G__Hist_100_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TH1::FitOptionsMake((Option_t*) G__int(libp->para[0]), *(Foption_t*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Hist_100_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TH1*) G__getstructoffset())->Add((TF1*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Option_t*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TH1*) G__getstructoffset())->Add((TF1*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TH1*) G__getstructoffset())->Add((TF1*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

static int G__G__Hist_100_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letdouble(result7, 100, (double) ((const TH1*) G__getstructoffset())->Chi2Test((TH1*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2])));
      break;
   case 2:
      G__letdouble(result7, 100, (double) ((const TH1*) G__getstructoffset())->Chi2Test((TH1*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((const TH1*) G__getstructoffset())->Chi2Test((TH1*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_100_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 6:
      G__letdouble(result7, 100, (double) ((const TH1*) G__getstructoffset())->Chi2TestX((TH1*) G__int(libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])
, *(Int_t*) G__Intref(&libp->para[2]), *(Int_t*) G__Intref(&libp->para[3])
, (Option_t*) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5])));
      break;
   case 5:
      G__letdouble(result7, 100, (double) ((const TH1*) G__getstructoffset())->Chi2TestX((TH1*) G__int(libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])
, *(Int_t*) G__Intref(&libp->para[2]), *(Int_t*) G__Intref(&libp->para[3])
, (Option_t*) G__int(libp->para[4])));
      break;
   case 4:
      G__letdouble(result7, 100, (double) ((const TH1*) G__getstructoffset())->Chi2TestX((TH1*) G__int(libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])
, *(Int_t*) G__Intref(&libp->para[2]), *(Int_t*) G__Intref(&libp->para[3])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Hist_100_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TH1*) G__getstructoffset())->Divide((TF1*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TH1*) G__getstructoffset())->Divide((TF1*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Hist_100_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      ((TH1*) G__getstructoffset())->Divide((TH1*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Option_t*) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TH1*) G__getstructoffset())->Divide((TH1*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TH1*) G__getstructoffset())->Divide((TH1*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TH1*) G__getstructoffset())->Divide((TH1*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_100_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 85, (long) ((const TH1*) G__getstructoffset())->DrawCopy((Option_t*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((const TH1*) G__getstructoffset())->DrawCopy());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_100_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 85, (long) ((const TH1*) G__getstructoffset())->DrawNormalized((Option_t*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((const TH1*) G__getstructoffset())->DrawNormalized((Option_t*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((const TH1*) G__getstructoffset())->DrawNormalized());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

static int G__G__Hist_100_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TH1*) G__getstructoffset())->Fill((Double_t) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_100_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TH1*) G__getstructoffset())->Fill((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Hist_100_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TH1*) G__getstructoffset())->FillN((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TH1*) G__getstructoffset())->FillN((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_100_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TH1*) G__getstructoffset())->FillN((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Hist_100_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 105, (long) ((TH1*) G__getstructoffset())->FindBin((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 105, (long) ((TH1*) G__getstructoffset())->FindBin((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((TH1*) G__getstructoffset())->FindBin((Double_t) G__double(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_100_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 105, (long) ((const TH1*) G__getstructoffset())->FindFixBin((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 105, (long) ((const TH1*) G__getstructoffset())->FindFixBin((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((const TH1*) G__getstructoffset())->FindFixBin((Double_t) G__double(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_100_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 105, (long) ((const TH1*) G__getstructoffset())->FindFirstBinAbove((Double_t) G__double(libp->para[0]), (Int_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((const TH1*) G__getstructoffset())->FindFirstBinAbove((Double_t) G__double(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 105, (long) ((const TH1*) G__getstructoffset())->FindFirstBinAbove());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_100_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 105, (long) ((const TH1*) G__getstructoffset())->FindLastBinAbove((Double_t) G__double(libp->para[0]), (Int_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((const TH1*) G__getstructoffset())->FindLastBinAbove((Double_t) G__double(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 105, (long) ((const TH1*) G__getstructoffset())->FindLastBinAbove());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_100_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      {
         TFitResultPtr* pobj;
         TFitResultPtr xobj = ((TH1*) G__getstructoffset())->Fit((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
         pobj = new TFitResultPtr(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 4:
      {
         TFitResultPtr* pobj;
         TFitResultPtr xobj = ((TH1*) G__getstructoffset())->Fit((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3]));
         pobj = new TFitResultPtr(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 3:
      {
         TFitResultPtr* pobj;
         TFitResultPtr xobj = ((TH1*) G__getstructoffset())->Fit((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]));
         pobj = new TFitResultPtr(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 2:
      {
         TFitResultPtr* pobj;
         TFitResultPtr xobj = ((TH1*) G__getstructoffset())->Fit((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
         pobj = new TFitResultPtr(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 1:
      {
         TFitResultPtr* pobj;
         TFitResultPtr xobj = ((TH1*) G__getstructoffset())->Fit((const char*) G__int(libp->para[0]));
         pobj = new TFitResultPtr(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__G__Hist_100_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      {
         TFitResultPtr* pobj;
         TFitResultPtr xobj = ((TH1*) G__getstructoffset())->Fit((TF1*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
         pobj = new TFitResultPtr(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 4:
      {
         TFitResultPtr* pobj;
         TFitResultPtr xobj = ((TH1*) G__getstructoffset())->Fit((TF1*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3]));
         pobj = new TFitResultPtr(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 3:
      {
         TFitResultPtr* pobj;
         TFitResultPtr xobj = ((TH1*) G__getstructoffset())->Fit((TF1*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]));
         pobj = new TFitResultPtr(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 2:
      {
         TFitResultPtr* pobj;
         TFitResultPtr xobj = ((TH1*) G__getstructoffset())->Fit((TF1*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
         pobj = new TFitResultPtr(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 1:
      {
         TFitResultPtr* pobj;
         TFitResultPtr xobj = ((TH1*) G__getstructoffset())->Fit((TF1*) G__int(libp->para[0]));
         pobj = new TFitResultPtr(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__G__Hist_100_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TH1*) G__getstructoffset())->FitPanel();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_100_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 85, (long) ((TH1*) G__getstructoffset())->GetAsymmetry((TH1*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((TH1*) G__getstructoffset())->GetAsymmetry((TH1*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TH1*) G__getstructoffset())->GetAsymmetry((TH1*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Hist_100_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TH1*) G__getstructoffset())->GetBuffer());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Hist_100_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((TH1*) G__getstructoffset())->GetIntegral());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Hist_100_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 115, (long) ((const TH1*) G__getstructoffset())->GetAxisColor((Option_t*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 115, (long) ((const TH1*) G__getstructoffset())->GetAxisColor());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_100_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 115, (long) ((const TH1*) G__getstructoffset())->GetLabelColor((Option_t*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 115, (long) ((const TH1*) G__getstructoffset())->GetLabelColor());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_100_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 115, (long) ((const TH1*) G__getstructoffset())->GetLabelFont((Option_t*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 115, (long) ((const TH1*) G__getstructoffset())->GetLabelFont());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_100_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 102, (double) ((const TH1*) G__getstructoffset())->GetLabelOffset((Option_t*) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 102, (double) ((const TH1*) G__getstructoffset())->GetLabelOffset());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_100_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 102, (double) ((const TH1*) G__getstructoffset())->GetLabelSize((Option_t*) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 102, (double) ((const TH1*) G__getstructoffset())->GetLabelSize());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_100_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 115, (long) ((const TH1*) G__getstructoffset())->GetTitleFont((Option_t*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 115, (long) ((const TH1*) G__getstructoffset())->GetTitleFont());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_100_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 102, (double) ((const TH1*) G__getstructoffset())->GetTitleOffset((Option_t*) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 102, (double) ((const TH1*) G__getstructoffset())->GetTitleOffset());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_100_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 102, (double) ((const TH1*) G__getstructoffset())->GetTitleSize((Option_t*) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 102, (double) ((const TH1*) G__getstructoffset())->GetTitleSize());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_100_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 102, (double) ((const TH1*) G__getstructoffset())->GetTickLength((Option_t*) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 102, (double) ((const TH1*) G__getstructoffset())->GetTickLength());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_100_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TH1*) G__getstructoffset())->GetBarOffset());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_100_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TH1*) G__getstructoffset())->GetBarWidth());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__G__Hist_100_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 105, (long) ((const TH1*) G__getstructoffset())->GetBin((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 105, (long) ((const TH1*) G__getstructoffset())->GetBin((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((const TH1*) G__getstructoffset())->GetBin((Int_t) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_100_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TH1*) G__getstructoffset())->GetBinXYZ((Int_t) G__int(libp->para[0]), *(Int_t*) G__Intref(&libp->para[1])
, *(Int_t*) G__Intref(&libp->para[2]), *(Int_t*) G__Intref(&libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

static int G__G__Hist_100_0_91(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letdouble(result7, 100, (double) ((const TH1*) G__getstructoffset())->GetBinWithContent((Double_t) G__double(libp->para[0]), *(Int_t*) G__Intref(&libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Double_t) G__double(libp->para[4])));
      break;
   case 4:
      G__letdouble(result7, 100, (double) ((const TH1*) G__getstructoffset())->GetBinWithContent((Double_t) G__double(libp->para[0]), *(Int_t*) G__Intref(&libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])));
      break;
   case 3:
      G__letdouble(result7, 100, (double) ((const TH1*) G__getstructoffset())->GetBinWithContent((Double_t) G__double(libp->para[0]), *(Int_t*) G__Intref(&libp->para[1])
, (Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letdouble(result7, 100, (double) ((const TH1*) G__getstructoffset())->GetBinWithContent((Double_t) G__double(libp->para[0]), *(Int_t*) G__Intref(&libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

static int G__G__Hist_100_0_105(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TH1*) G__getstructoffset())->GetMaximumBin(*(Int_t*) G__Intref(&libp->para[0]), *(Int_t*) G__Intref(&libp->para[1])
, *(Int_t*) G__Intref(&libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__G__Hist_100_0_109(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TH1*) G__getstructoffset())->GetMinimumBin(*(Int_t*) G__Intref(&libp->para[0]), *(Int_t*) G__Intref(&libp->para[1])
, *(Int_t*) G__Intref(&libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Hist_100_0_112(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TH1*) G__getstructoffset())->GetMeanError((Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TH1*) G__getstructoffset())->GetMeanError());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

static int G__G__Hist_100_0_120(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 105, (long) ((TH1*) G__getstructoffset())->GetQuantiles((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 105, (long) ((TH1*) G__getstructoffset())->GetQuantiles((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

static int G__G__Hist_100_0_127(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TH1*) G__getstructoffset())->GetRMS((Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TH1*) G__getstructoffset())->GetRMS());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_100_0_128(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TH1*) G__getstructoffset())->GetRMSError((Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TH1*) G__getstructoffset())->GetRMSError());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

static int G__G__Hist_100_0_133(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TH1*) G__getstructoffset())->Integral((Option_t*) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TH1*) G__getstructoffset())->Integral());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_100_0_134(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letdouble(result7, 100, (double) ((const TH1*) G__getstructoffset())->Integral((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2])));
      break;
   case 2:
      G__letdouble(result7, 100, (double) ((const TH1*) G__getstructoffset())->Integral((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_100_0_135(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letdouble(result7, 100, (double) ((const TH1*) G__getstructoffset())->IntegralAndError((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2]), (Option_t*) G__int(libp->para[3])));
      break;
   case 3:
      G__letdouble(result7, 100, (double) ((const TH1*) G__getstructoffset())->IntegralAndError((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

static int G__G__Hist_100_0_141(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letdouble(result7, 100, (double) ((const TH1*) G__getstructoffset())->KolmogorovTest((TH1*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((const TH1*) G__getstructoffset())->KolmogorovTest((TH1*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__G__Hist_100_0_145(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((TH1*) G__getstructoffset())->Merge((TCollection*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_100_0_146(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TH1*) G__getstructoffset())->Multiply((TF1*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TH1*) G__getstructoffset())->Multiply((TF1*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Hist_100_0_148(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      ((TH1*) G__getstructoffset())->Multiply((TH1*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Option_t*) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TH1*) G__getstructoffset())->Multiply((TH1*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TH1*) G__getstructoffset())->Multiply((TH1*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TH1*) G__getstructoffset())->Multiply((TH1*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Hist_100_0_152(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 85, (long) ((TH1*) G__getstructoffset())->Rebin((Int_t) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((TH1*) G__getstructoffset())->Rebin((Int_t) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TH1*) G__getstructoffset())->Rebin((Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((TH1*) G__getstructoffset())->Rebin());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

static int G__G__Hist_100_0_159(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TH1*) G__getstructoffset())->Scale((Double_t) G__double(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TH1*) G__getstructoffset())->Scale((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TH1*) G__getstructoffset())->Scale();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Hist_100_0_161(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TH1*) G__getstructoffset())->SetAxisRange((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Option_t*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TH1*) G__getstructoffset())->SetAxisRange((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

static int G__G__Hist_100_0_172(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TH1*) G__getstructoffset())->SetBins((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Hist_100_0_174(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TH1*) G__getstructoffset())->SetBins(
(Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_100_0_175(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TH1*) G__getstructoffset())->SetBins((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

static int G__G__Hist_100_0_190(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TH1*) G__getstructoffset())->SetLabelOffset((Float_t) G__double(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TH1*) G__getstructoffset())->SetLabelOffset((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TH1*) G__getstructoffset())->SetLabelOffset();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_100_0_191(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TH1*) G__getstructoffset())->SetLabelSize((Float_t) G__double(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TH1*) G__getstructoffset())->SetLabelSize((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TH1*) G__getstructoffset())->SetLabelSize();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

static int G__G__Hist_100_0_200(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TH1*) G__getstructoffset())->SetTickLength((Float_t) G__double(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TH1*) G__getstructoffset())->SetTickLength((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TH1*) G__getstructoffset())->SetTickLength();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Hist_100_0_202(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TH1*) G__getstructoffset())->SetTitleOffset((Float_t) G__double(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TH1*) G__getstructoffset())->SetTitleOffset((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TH1*) G__getstructoffset())->SetTitleOffset();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_100_0_203(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TH1*) G__getstructoffset())->SetTitleSize((Float_t) G__double(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TH1*) G__getstructoffset())->SetTitleSize((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TH1*) G__getstructoffset())->SetTitleSize();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

static int G__G__Hist_100_0_209(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 105, (long) ((TH1*) G__getstructoffset())->ShowPeaks((Double_t) G__double(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 105, (long) ((TH1*) G__getstructoffset())->ShowPeaks((Double_t) G__double(libp->para[0]), (Option_t*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((TH1*) G__getstructoffset())->ShowPeaks((Double_t) G__double(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 105, (long) ((TH1*) G__getstructoffset())->ShowPeaks());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Hist_100_0_211(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      TH1::SmoothArray((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      TH1::SmoothArray((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Hist_100_0_215(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TH1::TransformHisto((TVirtualFFT*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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


/* THnSparse */
static int G__G__Hist_101_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 85, (long) THnSparse::CreateSparse((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TH1*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 85, (long) THnSparse::CreateSparse((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TH1*) G__int(libp->para[2])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__G__Hist_101_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letLonglong(result7, 110, (G__int64) ((THnSparse*) G__getstructoffset())->Fill((Double_t*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])));
      break;
   case 1:
      G__letLonglong(result7, 110, (G__int64) ((THnSparse*) G__getstructoffset())->Fill((Double_t*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_101_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letLonglong(result7, 110, (G__int64) ((THnSparse*) G__getstructoffset())->Fill((const char**) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])));
      break;
   case 1:
      G__letLonglong(result7, 110, (G__int64) ((THnSparse*) G__getstructoffset())->Fill((const char**) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_101_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      {
         TFitResultPtr* pobj;
         TFitResultPtr xobj = ((THnSparse*) G__getstructoffset())->Fit((TF1*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]));
         pobj = new TFitResultPtr(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 2:
      {
         TFitResultPtr* pobj;
         TFitResultPtr xobj = ((THnSparse*) G__getstructoffset())->Fit((TF1*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
         pobj = new TFitResultPtr(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 1:
      {
         TFitResultPtr* pobj;
         TFitResultPtr xobj = ((THnSparse*) G__getstructoffset())->Fit((TF1*) G__int(libp->para[0]));
         pobj = new TFitResultPtr(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__G__Hist_101_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((THnSparse*) G__getstructoffset())->GetListOfFunctions());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Hist_101_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((const THnSparse*) G__getstructoffset())->GetNbins());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__G__Hist_101_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letLonglong(result7, 110, (G__int64) ((THnSparse*) G__getstructoffset())->GetBin((const Int_t*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letLonglong(result7, 110, (G__int64) ((THnSparse*) G__getstructoffset())->GetBin((const Int_t*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_101_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letLonglong(result7, 110, (G__int64) ((THnSparse*) G__getstructoffset())->GetBin((Double_t*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letLonglong(result7, 110, (G__int64) ((THnSparse*) G__getstructoffset())->GetBin((Double_t*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_101_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letLonglong(result7, 110, (G__int64) ((THnSparse*) G__getstructoffset())->GetBin((const char**) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letLonglong(result7, 110, (G__int64) ((THnSparse*) G__getstructoffset())->GetBin((const char**) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Hist_101_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THnSparse*) G__getstructoffset())->SetBinContent((const Int_t*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_101_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THnSparse*) G__getstructoffset())->SetBinContent((Long64_t) G__Longlong(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_101_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THnSparse*) G__getstructoffset())->SetBinError((const Int_t*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_101_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THnSparse*) G__getstructoffset())->SetBinError((Long64_t) G__Longlong(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_101_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((THnSparse*) G__getstructoffset())->AddBinContent((const Int_t*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((THnSparse*) G__getstructoffset())->AddBinContent((const Int_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_101_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((THnSparse*) G__getstructoffset())->AddBinContent((Long64_t) G__Longlong(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((THnSparse*) G__getstructoffset())->AddBinContent((Long64_t) G__Longlong(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Hist_101_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letdouble(result7, 100, (double) ((const THnSparse*) G__getstructoffset())->GetBinContent((Long64_t) G__Longlong(libp->para[0]), (Int_t*) G__int(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((const THnSparse*) G__getstructoffset())->GetBinContent((Long64_t) G__Longlong(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Hist_101_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const THnSparse*) G__getstructoffset())->GetBinError((Long64_t) G__Longlong(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

static int G__G__Hist_101_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 85, (long) ((const THnSparse*) G__getstructoffset())->Projection((Int_t) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((const THnSparse*) G__getstructoffset())->Projection((Int_t) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_101_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 85, (long) ((const THnSparse*) G__getstructoffset())->Projection((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((const THnSparse*) G__getstructoffset())->Projection((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_101_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 85, (long) ((const THnSparse*) G__getstructoffset())->Projection((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 85, (long) ((const THnSparse*) G__getstructoffset())->Projection((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_101_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 85, (long) ((const THnSparse*) G__getstructoffset())->Projection((Int_t) G__int(libp->para[0]), (const Int_t*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((const THnSparse*) G__getstructoffset())->Projection((Int_t) G__int(libp->para[0]), (const Int_t*) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Hist_101_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((THnSparse*) G__getstructoffset())->Merge((TCollection*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__G__Hist_101_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((THnSparse*) G__getstructoffset())->Multiply((TF1*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((THnSparse*) G__getstructoffset())->Multiply((TF1*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Hist_101_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      ((THnSparse*) G__getstructoffset())->Divide((THnSparse*) G__int(libp->para[0]), (THnSparse*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Option_t*) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((THnSparse*) G__getstructoffset())->Divide((THnSparse*) G__int(libp->para[0]), (THnSparse*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((THnSparse*) G__getstructoffset())->Divide((THnSparse*) G__int(libp->para[0]), (THnSparse*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((THnSparse*) G__getstructoffset())->Divide((THnSparse*) G__int(libp->para[0]), (THnSparse*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

static int G__G__Hist_101_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((const THnSparse*) G__getstructoffset())->PrintEntries((Long64_t) G__Longlong(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
, (Option_t*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((const THnSparse*) G__getstructoffset())->PrintEntries((Long64_t) G__Longlong(libp->para[0]), (Long64_t) G__Longlong(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((const THnSparse*) G__getstructoffset())->PrintEntries((Long64_t) G__Longlong(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((const THnSparse*) G__getstructoffset())->PrintEntries();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_101_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const THnSparse*) G__getstructoffset())->PrintBin((Int_t*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_101_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const THnSparse*) G__getstructoffset())->PrintBin((Long64_t) G__Longlong(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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


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

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

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

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

static int G__G__Hist_102_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TF1* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TF1(
(const char*) G__int(libp->para[0]), *((ROOT::Math::ParamFunctor*) G__int(libp->para[1]))
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TF1(
(const char*) G__int(libp->para[0]), *((ROOT::Math::ParamFunctor*) G__int(libp->para[1]))
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TF1(
(const char*) G__int(libp->para[0]), *((ROOT::Math::ParamFunctor*) G__int(libp->para[1]))
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
     } else {
       p = new((void*) gvp) TF1(
(const char*) G__int(libp->para[0]), *((ROOT::Math::ParamFunctor*) G__int(libp->para[1]))
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TF1(
(const char*) G__int(libp->para[0]), *((ROOT::Math::ParamFunctor*) G__int(libp->para[1]))
, (Double_t) G__double(libp->para[2]));
     } else {
       p = new((void*) gvp) TF1(
(const char*) G__int(libp->para[0]), *((ROOT::Math::ParamFunctor*) G__int(libp->para[1]))
, (Double_t) G__double(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TF1((const char*) G__int(libp->para[0]), *((ROOT::Math::ParamFunctor*) G__int(libp->para[1])));
     } else {
       p = new((void*) gvp) TF1((const char*) G__int(libp->para[0]), *((ROOT::Math::ParamFunctor*) G__int(libp->para[1])));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TF1));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_102_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TF1* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 6
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TF1(
(const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Int_t) G__int(libp->para[4]), (const char*) G__int(libp->para[5]));
   } else {
     p = new((void*) gvp) TF1(
(const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Int_t) G__int(libp->para[4]), (const char*) G__int(libp->para[5]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TF1));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__G__Hist_102_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) ((const TF1*) G__getstructoffset())->Derivative((Double_t) G__double(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2])));
      break;
   case 2:
      G__letdouble(result7, 100, (double) ((const TF1*) G__getstructoffset())->Derivative((Double_t) G__double(libp->para[0]), (Double_t*) G__int(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((const TF1*) G__getstructoffset())->Derivative((Double_t) G__double(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_102_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) ((const TF1*) G__getstructoffset())->Derivative2((Double_t) G__double(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2])));
      break;
   case 2:
      G__letdouble(result7, 100, (double) ((const TF1*) G__getstructoffset())->Derivative2((Double_t) G__double(libp->para[0]), (Double_t*) G__int(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((const TF1*) G__getstructoffset())->Derivative2((Double_t) G__double(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Hist_102_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) TF1::DerivativeError());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_102_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 85, (long) ((const TF1*) G__getstructoffset())->DrawCopy((Option_t*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((const TF1*) G__getstructoffset())->DrawCopy());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Hist_102_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TF1*) G__getstructoffset())->DrawF1((const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Option_t*) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TF1*) G__getstructoffset())->DrawF1((const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_102_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letdouble(result7, 100, (double) ((const TF1*) G__getstructoffset())->operator()((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])));
      break;
   case 3:
      G__letdouble(result7, 100, (double) ((const TF1*) G__getstructoffset())->operator()((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2])));
      break;
   case 2:
      G__letdouble(result7, 100, (double) ((const TF1*) G__getstructoffset())->operator()((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((const TF1*) G__getstructoffset())->operator()((Double_t) G__double(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

static int G__G__Hist_102_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letdouble(result7, 100, (double) ((const TF1*) G__getstructoffset())->GetMaximum((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Bool_t) G__int(libp->para[4])));
      break;
   case 4:
      G__letdouble(result7, 100, (double) ((const TF1*) G__getstructoffset())->GetMaximum((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Int_t) G__int(libp->para[3])));
      break;
   case 3:
      G__letdouble(result7, 100, (double) ((const TF1*) G__getstructoffset())->GetMaximum((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2])));
      break;
   case 2:
      G__letdouble(result7, 100, (double) ((const TF1*) G__getstructoffset())->GetMaximum((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((const TF1*) G__getstructoffset())->GetMaximum((Double_t) G__double(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TF1*) G__getstructoffset())->GetMaximum());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_102_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letdouble(result7, 100, (double) ((const TF1*) G__getstructoffset())->GetMinimum((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Bool_t) G__int(libp->para[4])));
      break;
   case 4:
      G__letdouble(result7, 100, (double) ((const TF1*) G__getstructoffset())->GetMinimum((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Int_t) G__int(libp->para[3])));
      break;
   case 3:
      G__letdouble(result7, 100, (double) ((const TF1*) G__getstructoffset())->GetMinimum((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2])));
      break;
   case 2:
      G__letdouble(result7, 100, (double) ((const TF1*) G__getstructoffset())->GetMinimum((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((const TF1*) G__getstructoffset())->GetMinimum((Double_t) G__double(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TF1*) G__getstructoffset())->GetMinimum());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_102_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letdouble(result7, 100, (double) ((const TF1*) G__getstructoffset())->GetMaximumX((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Bool_t) G__int(libp->para[4])));
      break;
   case 4:
      G__letdouble(result7, 100, (double) ((const TF1*) G__getstructoffset())->GetMaximumX((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Int_t) G__int(libp->para[3])));
      break;
   case 3:
      G__letdouble(result7, 100, (double) ((const TF1*) G__getstructoffset())->GetMaximumX((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2])));
      break;
   case 2:
      G__letdouble(result7, 100, (double) ((const TF1*) G__getstructoffset())->GetMaximumX((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((const TF1*) G__getstructoffset())->GetMaximumX((Double_t) G__double(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TF1*) G__getstructoffset())->GetMaximumX());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_102_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letdouble(result7, 100, (double) ((const TF1*) G__getstructoffset())->GetMinimumX((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Bool_t) G__int(libp->para[4])));
      break;
   case 4:
      G__letdouble(result7, 100, (double) ((const TF1*) G__getstructoffset())->GetMinimumX((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Int_t) G__int(libp->para[3])));
      break;
   case 3:
      G__letdouble(result7, 100, (double) ((const TF1*) G__getstructoffset())->GetMinimumX((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2])));
      break;
   case 2:
      G__letdouble(result7, 100, (double) ((const TF1*) G__getstructoffset())->GetMinimumX((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((const TF1*) G__getstructoffset())->GetMinimumX((Double_t) G__double(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TF1*) G__getstructoffset())->GetMinimumX());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

static int G__G__Hist_102_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TF1*) G__getstructoffset())->GetParErrors());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_102_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TF1*) G__getstructoffset())->GetParLimits((Int_t) G__int(libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

static int G__G__Hist_102_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TF1*) G__getstructoffset())->GetRange(*(Double_t*) G__Doubleref(&libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_102_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TF1*) G__getstructoffset())->GetRange(*(Double_t*) G__Doubleref(&libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2]), *(Double_t*) G__Doubleref(&libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_102_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TF1*) G__getstructoffset())->GetRange(*(Double_t*) G__Doubleref(&libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2]), *(Double_t*) G__Doubleref(&libp->para[3])
, *(Double_t*) G__Doubleref(&libp->para[4]), *(Double_t*) G__Doubleref(&libp->para[5]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Hist_102_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 6:
      G__letdouble(result7, 100, (double) ((const TF1*) G__getstructoffset())->GetX((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Bool_t) G__int(libp->para[5])));
      break;
   case 5:
      G__letdouble(result7, 100, (double) ((const TF1*) G__getstructoffset())->GetX((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Int_t) G__int(libp->para[4])));
      break;
   case 4:
      G__letdouble(result7, 100, (double) ((const TF1*) G__getstructoffset())->GetX((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])));
      break;
   case 3:
      G__letdouble(result7, 100, (double) ((const TF1*) G__getstructoffset())->GetX((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2])));
      break;
   case 2:
      G__letdouble(result7, 100, (double) ((const TF1*) G__getstructoffset())->GetX((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((const TF1*) G__getstructoffset())->GetX((Double_t) G__double(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_102_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TF1*) G__getstructoffset())->GetXmin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_102_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TF1*) G__getstructoffset())->GetXmax());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_102_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TF1*) G__getstructoffset())->GetXaxis());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_102_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TF1*) G__getstructoffset())->GetYaxis());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_102_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TF1*) G__getstructoffset())->GetZaxis());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_102_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letdouble(result7, 100, (double) ((TF1*) G__getstructoffset())->GradientPar((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2])));
      break;
   case 2:
      G__letdouble(result7, 100, (double) ((TF1*) G__getstructoffset())->GradientPar((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_102_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TF1*) G__getstructoffset())->GradientPar((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TF1*) G__getstructoffset())->GradientPar((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_102_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TF1*) G__getstructoffset())->InitArgs((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_102_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TF1::InitStandardFunctions();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_102_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letdouble(result7, 100, (double) ((TF1*) G__getstructoffset())->Integral((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])));
      break;
   case 3:
      G__letdouble(result7, 100, (double) ((TF1*) G__getstructoffset())->Integral((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t*) G__int(libp->para[2])));
      break;
   case 2:
      G__letdouble(result7, 100, (double) ((TF1*) G__getstructoffset())->Integral((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_102_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letdouble(result7, 100, (double) ((TF1*) G__getstructoffset())->Integral((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4])));
      break;
   case 4:
      G__letdouble(result7, 100, (double) ((TF1*) G__getstructoffset())->Integral((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_102_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 7:
      G__letdouble(result7, 100, (double) ((TF1*) G__getstructoffset())->Integral(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6])));
      break;
   case 6:
      G__letdouble(result7, 100, (double) ((TF1*) G__getstructoffset())->Integral((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_102_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letdouble(result7, 100, (double) ((TF1*) G__getstructoffset())->IntegralError((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Double_t) G__double(libp->para[4])));
      break;
   case 4:
      G__letdouble(result7, 100, (double) ((TF1*) G__getstructoffset())->IntegralError((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])));
      break;
   case 3:
      G__letdouble(result7, 100, (double) ((TF1*) G__getstructoffset())->IntegralError((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t*) G__int(libp->para[2])));
      break;
   case 2:
      G__letdouble(result7, 100, (double) ((TF1*) G__getstructoffset())->IntegralError((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_102_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 6:
      G__letdouble(result7, 100, (double) ((TF1*) G__getstructoffset())->IntegralError((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]), (Double_t) G__double(libp->para[5])));
      break;
   case 5:
      G__letdouble(result7, 100, (double) ((TF1*) G__getstructoffset())->IntegralError((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4])));
      break;
   case 4:
      G__letdouble(result7, 100, (double) ((TF1*) G__getstructoffset())->IntegralError((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])));
      break;
   case 3:
      G__letdouble(result7, 100, (double) ((TF1*) G__getstructoffset())->IntegralError((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_102_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 7:
      G__letdouble(result7, 100, (double) ((TF1*) G__getstructoffset())->IntegralFast(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t*) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6])));
      break;
   case 6:
      G__letdouble(result7, 100, (double) ((TF1*) G__getstructoffset())->IntegralFast((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t*) G__int(libp->para[5])));
      break;
   case 5:
      G__letdouble(result7, 100, (double) ((TF1*) G__getstructoffset())->IntegralFast((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_102_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TF1*) G__getstructoffset())->IntegralMultiple(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Double_t) G__double(libp->para[5])
, *(Double_t*) G__Doubleref(&libp->para[6]), *(Int_t*) G__Intref(&libp->para[7])
, *(Int_t*) G__Intref(&libp->para[8])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_102_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TF1*) G__getstructoffset())->IntegralMultiple((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, *(Double_t*) G__Doubleref(&libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_102_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TF1*) G__getstructoffset())->IsInside((Double_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_102_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TF1*) G__getstructoffset())->ReleaseParameter((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_102_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TF1*) G__getstructoffset())->Save((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_102_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TF1*) G__getstructoffset())->SetChisquare((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_102_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TF1*) G__getstructoffset())->SetFitResult(*(ROOT::Fit::FitResult*) libp->para[0].ref, (const Int_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TF1*) G__getstructoffset())->SetFitResult(*(ROOT::Fit::FitResult*) libp->para[0].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_102_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TF1*) G__getstructoffset())->SetMaximum((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TF1*) G__getstructoffset())->SetMaximum();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_102_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TF1*) G__getstructoffset())->SetMinimum((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TF1*) G__getstructoffset())->SetMinimum();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_102_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TF1*) G__getstructoffset())->SetNDF((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_102_0_83(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TF1*) G__getstructoffset())->SetNumberFitPoints((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_102_0_84(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TF1*) G__getstructoffset())->SetNpx((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TF1*) G__getstructoffset())->SetNpx();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_102_0_85(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TF1*) G__getstructoffset())->SetParError((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_102_0_86(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TF1*) G__getstructoffset())->SetParErrors((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_102_0_87(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TF1*) G__getstructoffset())->SetParLimits((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_102_0_88(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TF1*) G__getstructoffset())->SetParent((TObject*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TF1*) G__getstructoffset())->SetParent();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_102_0_89(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TF1*) G__getstructoffset())->SetRange((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_102_0_90(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TF1*) G__getstructoffset())->SetRange((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_102_0_91(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TF1*) G__getstructoffset())->SetRange((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_102_0_92(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TF1*) G__getstructoffset())->SetSavedPoint((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_102_0_95(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TF1::GetCurrent());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_102_0_96(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      TF1::AbsValue((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      TF1::AbsValue();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_102_0_97(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      TF1::RejectPoint((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      TF1::RejectPoint();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_102_0_98(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TF1::RejectedPoint());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_102_0_99(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TF1::SetCurrent((TF1*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_102_0_100(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letdouble(result7, 100, (double) ((TF1*) G__getstructoffset())->Moment((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Double_t) G__double(libp->para[4])));
      break;
   case 4:
      G__letdouble(result7, 100, (double) ((TF1*) G__getstructoffset())->Moment((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t*) G__int(libp->para[3])));
      break;
   case 3:
      G__letdouble(result7, 100, (double) ((TF1*) G__getstructoffset())->Moment((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_102_0_101(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letdouble(result7, 100, (double) ((TF1*) G__getstructoffset())->CentralMoment((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Double_t) G__double(libp->para[4])));
      break;
   case 4:
      G__letdouble(result7, 100, (double) ((TF1*) G__getstructoffset())->CentralMoment((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t*) G__int(libp->para[3])));
      break;
   case 3:
      G__letdouble(result7, 100, (double) ((TF1*) G__getstructoffset())->CentralMoment((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_102_0_102(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letdouble(result7, 100, (double) ((TF1*) G__getstructoffset())->Mean((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])));
      break;
   case 3:
      G__letdouble(result7, 100, (double) ((TF1*) G__getstructoffset())->Mean((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t*) G__int(libp->para[2])));
      break;
   case 2:
      G__letdouble(result7, 100, (double) ((TF1*) G__getstructoffset())->Mean((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_102_0_103(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letdouble(result7, 100, (double) ((TF1*) G__getstructoffset())->Variance((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])));
      break;
   case 3:
      G__letdouble(result7, 100, (double) ((TF1*) G__getstructoffset())->Variance((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t*) G__int(libp->para[2])));
      break;
   case 2:
      G__letdouble(result7, 100, (double) ((TF1*) G__getstructoffset())->Variance((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_102_0_104(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      TF1::CalcGaussLegendreSamplingPoints((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      TF1::CalcGaussLegendreSamplingPoints((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_102_0_105(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TF1::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_102_0_106(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TF1::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_102_0_107(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TF1::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_102_0_108(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TF1::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_102_0_112(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TF1*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_102_0_113(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TF1::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_102_0_114(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TF1::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_102_0_115(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TF1::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_102_0_116(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TF1::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TF1 G__TTF1;
static int G__G__Hist_102_0_117(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TF1*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TF1*) (soff+(sizeof(TF1)*i)))->~G__TTF1();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TF1*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TF1*) (soff))->~G__TTF1();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TF2 */
static int G__G__Hist_103_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TF2* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TF2[n];
     } else {
       p = new((void*) gvp) TF2[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TF2;
     } else {
       p = new((void*) gvp) TF2;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TF2));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_103_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TF2* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TF2(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
     } else {
       p = new((void*) gvp) TF2(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TF2(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
     } else {
       p = new((void*) gvp) TF2(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TF2(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
     } else {
       p = new((void*) gvp) TF2(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TF2(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]));
     } else {
       p = new((void*) gvp) TF2(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TF2((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TF2((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TF2));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_103_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TF2* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TF2(
(const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Int_t) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) TF2(
(const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Int_t) G__int(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TF2(
(const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
     } else {
       p = new((void*) gvp) TF2(
(const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TF2(
(const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
     } else {
       p = new((void*) gvp) TF2(
(const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TF2(
(const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
     } else {
       p = new((void*) gvp) TF2(
(const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TF2(
(const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]));
     } else {
       p = new((void*) gvp) TF2(
(const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TF2((const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TF2((const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TF2));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_103_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TF2* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TF2(
(const char*) G__int(libp->para[0]), *((ROOT::Math::ParamFunctor*) G__int(libp->para[1]))
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Int_t) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) TF2(
(const char*) G__int(libp->para[0]), *((ROOT::Math::ParamFunctor*) G__int(libp->para[1]))
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Int_t) G__int(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TF2(
(const char*) G__int(libp->para[0]), *((ROOT::Math::ParamFunctor*) G__int(libp->para[1]))
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
     } else {
       p = new((void*) gvp) TF2(
(const char*) G__int(libp->para[0]), *((ROOT::Math::ParamFunctor*) G__int(libp->para[1]))
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TF2(
(const char*) G__int(libp->para[0]), *((ROOT::Math::ParamFunctor*) G__int(libp->para[1]))
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
     } else {
       p = new((void*) gvp) TF2(
(const char*) G__int(libp->para[0]), *((ROOT::Math::ParamFunctor*) G__int(libp->para[1]))
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TF2(
(const char*) G__int(libp->para[0]), *((ROOT::Math::ParamFunctor*) G__int(libp->para[1]))
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
     } else {
       p = new((void*) gvp) TF2(
(const char*) G__int(libp->para[0]), *((ROOT::Math::ParamFunctor*) G__int(libp->para[1]))
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TF2(
(const char*) G__int(libp->para[0]), *((ROOT::Math::ParamFunctor*) G__int(libp->para[1]))
, (Double_t) G__double(libp->para[2]));
     } else {
       p = new((void*) gvp) TF2(
(const char*) G__int(libp->para[0]), *((ROOT::Math::ParamFunctor*) G__int(libp->para[1]))
, (Double_t) G__double(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TF2((const char*) G__int(libp->para[0]), *((ROOT::Math::ParamFunctor*) G__int(libp->para[1])));
     } else {
       p = new((void*) gvp) TF2((const char*) G__int(libp->para[0]), *((ROOT::Math::ParamFunctor*) G__int(libp->para[1])));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TF2));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_103_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TF2* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 8
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TF2(
(const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Int_t) G__int(libp->para[6]), (const char*) G__int(libp->para[7]));
   } else {
     p = new((void*) gvp) TF2(
(const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Int_t) G__int(libp->para[6]), (const char*) G__int(libp->para[7]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TF2));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_103_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TF2* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 10:
     //m: 10
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TF2(
(const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (void*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Int_t) G__int(libp->para[7])
, (const char*) G__int(libp->para[8]), (const char*) G__int(libp->para[9]));
     } else {
       p = new((void*) gvp) TF2(
(const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (void*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Int_t) G__int(libp->para[7])
, (const char*) G__int(libp->para[8]), (const char*) G__int(libp->para[9]));
     }
     break;
   case 9:
     //m: 9
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TF2(
(const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (void*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Int_t) G__int(libp->para[7])
, (const char*) G__int(libp->para[8]));
     } else {
       p = new((void*) gvp) TF2(
(const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (void*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Int_t) G__int(libp->para[7])
, (const char*) G__int(libp->para[8]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TF2));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_103_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TF2* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TF2(*(TF2*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TF2(*(TF2*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TF2));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_103_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TF2& obj = ((TF2*) G__getstructoffset())->operator=(*(TF2*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_103_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 6:
      ((TF2*) G__getstructoffset())->DrawF2((const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Option_t*) G__int(libp->para[5]));
      G__setnull(result7);
      break;
   case 5:
      ((TF2*) G__getstructoffset())->DrawF2((const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_103_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 105, (long) ((TF2*) G__getstructoffset())->GetContour((Double_t*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 105, (long) ((TF2*) G__getstructoffset())->GetContour());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_103_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TF2*) G__getstructoffset())->GetContourLevel((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_103_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TF2*) G__getstructoffset())->GetNpy());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_103_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TF2*) G__getstructoffset())->GetRandom2(*(Double_t*) G__Doubleref(&libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_103_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TF2*) G__getstructoffset())->GetMinimumXY(*(Double_t*) G__Doubleref(&libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_103_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TF2*) G__getstructoffset())->GetYmin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_103_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TF2*) G__getstructoffset())->GetYmax());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_103_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TF2*) G__getstructoffset())->CreateHistogram());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_103_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TF2*) G__getstructoffset())->SetNpy((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TF2*) G__getstructoffset())->SetNpy();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_103_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TF2*) G__getstructoffset())->SetContour((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TF2*) G__getstructoffset())->SetContour((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TF2*) G__getstructoffset())->SetContour();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_103_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TF2*) G__getstructoffset())->SetContourLevel((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_103_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 7:
      G__letdouble(result7, 100, (double) ((TF2*) G__getstructoffset())->Moment2(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6])));
      break;
   case 6:
      G__letdouble(result7, 100, (double) ((TF2*) G__getstructoffset())->Moment2((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_103_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 7:
      G__letdouble(result7, 100, (double) ((TF2*) G__getstructoffset())->CentralMoment2(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6])));
      break;
   case 6:
      G__letdouble(result7, 100, (double) ((TF2*) G__getstructoffset())->CentralMoment2((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_103_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letdouble(result7, 100, (double) ((TF2*) G__getstructoffset())->Mean2X((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4])));
      break;
   case 4:
      G__letdouble(result7, 100, (double) ((TF2*) G__getstructoffset())->Mean2X((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_103_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letdouble(result7, 100, (double) ((TF2*) G__getstructoffset())->Mean2Y((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4])));
      break;
   case 4:
      G__letdouble(result7, 100, (double) ((TF2*) G__getstructoffset())->Mean2Y((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_103_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letdouble(result7, 100, (double) ((TF2*) G__getstructoffset())->Variance2X((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4])));
      break;
   case 4:
      G__letdouble(result7, 100, (double) ((TF2*) G__getstructoffset())->Variance2X((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_103_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letdouble(result7, 100, (double) ((TF2*) G__getstructoffset())->Variance2Y((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4])));
      break;
   case 4:
      G__letdouble(result7, 100, (double) ((TF2*) G__getstructoffset())->Variance2Y((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_103_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letdouble(result7, 100, (double) ((TF2*) G__getstructoffset())->Covariance2XY((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4])));
      break;
   case 4:
      G__letdouble(result7, 100, (double) ((TF2*) G__getstructoffset())->Covariance2XY((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_103_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TF2::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_103_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TF2::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_103_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TF2::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_103_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TF2::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_103_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TF2*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_103_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TF2::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_103_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TF2::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_103_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TF2::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_103_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TF2::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TF2 G__TTF2;
static int G__G__Hist_103_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TF2*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TF2*) (soff+(sizeof(TF2)*i)))->~G__TTF2();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TF2*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TF2*) (soff))->~G__TTF2();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGraph */
static int G__G__Hist_104_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraph* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraph[n];
     } else {
       p = new((void*) gvp) TGraph[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraph;
     } else {
       p = new((void*) gvp) TGraph;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TGraph));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraph* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGraph((Int_t) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGraph((Int_t) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TGraph));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraph* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGraph(
(Int_t) G__int(libp->para[0]), (const Int_t*) G__int(libp->para[1])
, (const Int_t*) G__int(libp->para[2]));
   } else {
     p = new((void*) gvp) TGraph(
(Int_t) G__int(libp->para[0]), (const Int_t*) G__int(libp->para[1])
, (const Int_t*) G__int(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TGraph));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraph* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGraph(
(Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]));
   } else {
     p = new((void*) gvp) TGraph(
(Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TGraph));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraph* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGraph(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]));
   } else {
     p = new((void*) gvp) TGraph(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TGraph));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraph* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGraph(*(TGraph*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TGraph(*(TGraph*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TGraph));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGraph& obj = ((TGraph*) G__getstructoffset())->operator=(*(TGraph*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraph* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGraph(*(TVectorF*) libp->para[0].ref, *(TVectorF*) libp->para[1].ref);
   } else {
     p = new((void*) gvp) TGraph(*(TVectorF*) libp->para[0].ref, *(TVectorF*) libp->para[1].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TGraph));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraph* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGraph(*(TVectorD*) libp->para[0].ref, *(TVectorD*) libp->para[1].ref);
   } else {
     p = new((void*) gvp) TGraph(*(TVectorD*) libp->para[0].ref, *(TVectorD*) libp->para[1].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TGraph));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraph* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGraph((TH1*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGraph((TH1*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TGraph));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraph* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraph((TF1*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGraph((TF1*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraph((TF1*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGraph((TF1*) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TGraph));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraph* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraph(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGraph(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraph((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGraph((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraph((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGraph((const char*) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TGraph));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGraph*) G__getstructoffset())->Apply((TF1*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGraph*) G__getstructoffset())->Chisquare((TF1*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TGraph::CompareArg((TGraph*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TGraph::CompareX((TGraph*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TGraph::CompareY((TGraph*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TGraph::CompareRadius((TGraph*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGraph*) G__getstructoffset())->ComputeRange(*(Double_t*) G__Doubleref(&libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2]), *(Double_t*) G__Doubleref(&libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TGraph*) G__getstructoffset())->DrawGraph((Int_t) G__int(libp->para[0]), (const Int_t*) G__int(libp->para[1])
, (const Int_t*) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TGraph*) G__getstructoffset())->DrawGraph((Int_t) G__int(libp->para[0]), (const Int_t*) G__int(libp->para[1])
, (const Int_t*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TGraph*) G__getstructoffset())->DrawGraph((Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TGraph*) G__getstructoffset())->DrawGraph((Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TGraph*) G__getstructoffset())->DrawGraph((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TGraph*) G__getstructoffset())->DrawGraph((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TGraph*) G__getstructoffset())->DrawGraph((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGraph*) G__getstructoffset())->DrawGraph((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGraph*) G__getstructoffset())->DrawPanel();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letdouble(result7, 100, (double) ((const TGraph*) G__getstructoffset())->Eval((Double_t) G__double(libp->para[0]), (TSpline*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2])));
      break;
   case 2:
      G__letdouble(result7, 100, (double) ((const TGraph*) G__getstructoffset())->Eval((Double_t) G__double(libp->para[0]), (TSpline*) G__int(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((const TGraph*) G__getstructoffset())->Eval((Double_t) G__double(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGraph*) G__getstructoffset())->Expand((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGraph*) G__getstructoffset())->Expand((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      {
         TFitResultPtr* pobj;
         TFitResultPtr xobj = ((TGraph*) G__getstructoffset())->Fit((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]), (Axis_t) G__double(libp->para[3])
, (Axis_t) G__double(libp->para[4]));
         pobj = new TFitResultPtr(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 4:
      {
         TFitResultPtr* pobj;
         TFitResultPtr xobj = ((TGraph*) G__getstructoffset())->Fit((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]), (Axis_t) G__double(libp->para[3]));
         pobj = new TFitResultPtr(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 3:
      {
         TFitResultPtr* pobj;
         TFitResultPtr xobj = ((TGraph*) G__getstructoffset())->Fit((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]));
         pobj = new TFitResultPtr(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 2:
      {
         TFitResultPtr* pobj;
         TFitResultPtr xobj = ((TGraph*) G__getstructoffset())->Fit((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
         pobj = new TFitResultPtr(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 1:
      {
         TFitResultPtr* pobj;
         TFitResultPtr xobj = ((TGraph*) G__getstructoffset())->Fit((const char*) G__int(libp->para[0]));
         pobj = new TFitResultPtr(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__G__Hist_104_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      {
         TFitResultPtr* pobj;
         TFitResultPtr xobj = ((TGraph*) G__getstructoffset())->Fit((TF1*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]), (Axis_t) G__double(libp->para[3])
, (Axis_t) G__double(libp->para[4]));
         pobj = new TFitResultPtr(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 4:
      {
         TFitResultPtr* pobj;
         TFitResultPtr xobj = ((TGraph*) G__getstructoffset())->Fit((TF1*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]), (Axis_t) G__double(libp->para[3]));
         pobj = new TFitResultPtr(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 3:
      {
         TFitResultPtr* pobj;
         TFitResultPtr xobj = ((TGraph*) G__getstructoffset())->Fit((TF1*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]));
         pobj = new TFitResultPtr(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 2:
      {
         TFitResultPtr* pobj;
         TFitResultPtr xobj = ((TGraph*) G__getstructoffset())->Fit((TF1*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
         pobj = new TFitResultPtr(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 1:
      {
         TFitResultPtr* pobj;
         TFitResultPtr xobj = ((TGraph*) G__getstructoffset())->Fit((TF1*) G__int(libp->para[0]));
         pobj = new TFitResultPtr(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__G__Hist_104_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGraph*) G__getstructoffset())->FitPanel();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGraph*) G__getstructoffset())->GetEditable());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGraph*) G__getstructoffset())->GetFunction((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGraph*) G__getstructoffset())->GetHistogram());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGraph*) G__getstructoffset())->GetListOfFunctions());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGraph*) G__getstructoffset())->GetCorrelationFactor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGraph*) G__getstructoffset())->GetCovariance());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TGraph*) G__getstructoffset())->GetMean((Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TGraph*) G__getstructoffset())->GetMean());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TGraph*) G__getstructoffset())->GetRMS((Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TGraph*) G__getstructoffset())->GetRMS());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGraph*) G__getstructoffset())->GetMaxSize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGraph*) G__getstructoffset())->GetN());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGraph*) G__getstructoffset())->GetErrorX((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGraph*) G__getstructoffset())->GetErrorY((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGraph*) G__getstructoffset())->GetErrorXhigh((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGraph*) G__getstructoffset())->GetErrorXlow((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGraph*) G__getstructoffset())->GetErrorYhigh((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGraph*) G__getstructoffset())->GetErrorYlow((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TGraph*) G__getstructoffset())->GetX());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TGraph*) G__getstructoffset())->GetY());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TGraph*) G__getstructoffset())->GetEX());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TGraph*) G__getstructoffset())->GetEY());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TGraph*) G__getstructoffset())->GetEXhigh());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TGraph*) G__getstructoffset())->GetEXlow());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TGraph*) G__getstructoffset())->GetEYhigh());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TGraph*) G__getstructoffset())->GetEYlow());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TGraph*) G__getstructoffset())->GetEXlowd());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TGraph*) G__getstructoffset())->GetEXhighd());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TGraph*) G__getstructoffset())->GetEYlowd());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TGraph*) G__getstructoffset())->GetEYhighd());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGraph*) G__getstructoffset())->GetMaximum());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGraph*) G__getstructoffset())->GetMinimum());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGraph*) G__getstructoffset())->GetXaxis());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGraph*) G__getstructoffset())->GetYaxis());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGraph*) G__getstructoffset())->GetPoint((Int_t) G__int(libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGraph*) G__getstructoffset())->InitExpo((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGraph*) G__getstructoffset())->InitExpo((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGraph*) G__getstructoffset())->InitExpo();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGraph*) G__getstructoffset())->InitGaus((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGraph*) G__getstructoffset())->InitGaus((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGraph*) G__getstructoffset())->InitGaus();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGraph*) G__getstructoffset())->InitPolynom((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGraph*) G__getstructoffset())->InitPolynom((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGraph*) G__getstructoffset())->InitPolynom();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TGraph*) G__getstructoffset())->InsertPoint());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_83(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letdouble(result7, 100, (double) ((const TGraph*) G__getstructoffset())->Integral((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((const TGraph*) G__getstructoffset())->Integral((Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TGraph*) G__getstructoffset())->Integral());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_84(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGraph*) G__getstructoffset())->IsEditable());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_85(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGraph*) G__getstructoffset())->IsInside((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_86(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TGraph*) G__getstructoffset())->LeastSquareFit((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TGraph*) G__getstructoffset())->LeastSquareFit((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TGraph*) G__getstructoffset())->LeastSquareFit((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_87(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 6:
      ((TGraph*) G__getstructoffset())->LeastSquareLinearFit((Int_t) G__int(libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2]), *(Int_t*) G__Intref(&libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
      G__setnull(result7);
      break;
   case 5:
      ((TGraph*) G__getstructoffset())->LeastSquareLinearFit((Int_t) G__int(libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2]), *(Int_t*) G__Intref(&libp->para[3])
, (Double_t) G__double(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TGraph*) G__getstructoffset())->LeastSquareLinearFit((Int_t) G__int(libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2]), *(Int_t*) G__Intref(&libp->para[3]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_88(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TGraph*) G__getstructoffset())->Merge((TCollection*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_90(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGraph*) G__getstructoffset())->PaintGraph((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_91(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGraph*) G__getstructoffset())->PaintGrapHist((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_92(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGraph*) G__getstructoffset())->PaintStats((TF1*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_95(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TGraph*) G__getstructoffset())->RemovePoint());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_96(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TGraph*) G__getstructoffset())->RemovePoint((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_98(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGraph*) G__getstructoffset())->SetEditable((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGraph*) G__getstructoffset())->SetEditable();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_99(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGraph*) G__getstructoffset())->SetHistogram((TH1*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_100(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGraph*) G__getstructoffset())->SetMaximum((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGraph*) G__getstructoffset())->SetMaximum();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_101(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGraph*) G__getstructoffset())->SetMinimum((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGraph*) G__getstructoffset())->SetMinimum();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_102(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGraph*) G__getstructoffset())->Set((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_103(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGraph*) G__getstructoffset())->SetPoint((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_105(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TGraph*) G__getstructoffset())->Sort((Bool_t (*)(const TGraph*, Int_t, Int_t)) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TGraph*) G__getstructoffset())->Sort((Bool_t (*)(const TGraph*, Int_t, Int_t)) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TGraph*) G__getstructoffset())->Sort((Bool_t (*)(const TGraph*, Int_t, Int_t)) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGraph*) G__getstructoffset())->Sort((Bool_t (*)(const TGraph*, Int_t, Int_t)) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGraph*) G__getstructoffset())->Sort();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_107(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGraph*) G__getstructoffset())->Zero(
*(Int_t*) G__Intref(&libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, *(Double_t*) G__Doubleref(&libp->para[4]), *(Double_t*) G__Doubleref(&libp->para[5])
, (Int_t) G__int(libp->para[6]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_108(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGraph::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_109(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGraph::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_110(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGraph::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_111(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGraph::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_115(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGraph*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_116(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGraph::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_117(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGraph::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_118(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGraph::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_104_0_119(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGraph::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGraph G__TTGraph;
static int G__G__Hist_104_0_120(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGraph*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGraph*) (soff+(sizeof(TGraph)*i)))->~G__TTGraph();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGraph*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGraph*) (soff))->~G__TTGraph();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGraphErrors */
static int G__G__Hist_105_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraphErrors* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraphErrors[n];
     } else {
       p = new((void*) gvp) TGraphErrors[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraphErrors;
     } else {
       p = new((void*) gvp) TGraphErrors;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TGraphErrors));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_105_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraphErrors* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGraphErrors((Int_t) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGraphErrors((Int_t) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TGraphErrors));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_105_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraphErrors* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraphErrors(
(Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3])
, (Float_t*) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGraphErrors(
(Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3])
, (Float_t*) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraphErrors(
(Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGraphErrors(
(Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraphErrors(
(Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGraphErrors(
(Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TGraphErrors));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_105_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraphErrors* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraphErrors(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGraphErrors(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraphErrors(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGraphErrors(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraphErrors(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGraphErrors(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TGraphErrors));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_105_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraphErrors* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGraphErrors(
*(TVectorF*) libp->para[0].ref, *(TVectorF*) libp->para[1].ref
, *(TVectorF*) libp->para[2].ref, *(TVectorF*) libp->para[3].ref);
   } else {
     p = new((void*) gvp) TGraphErrors(
*(TVectorF*) libp->para[0].ref, *(TVectorF*) libp->para[1].ref
, *(TVectorF*) libp->para[2].ref, *(TVectorF*) libp->para[3].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TGraphErrors));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_105_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraphErrors* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGraphErrors(
*(TVectorD*) libp->para[0].ref, *(TVectorD*) libp->para[1].ref
, *(TVectorD*) libp->para[2].ref, *(TVectorD*) libp->para[3].ref);
   } else {
     p = new((void*) gvp) TGraphErrors(
*(TVectorD*) libp->para[0].ref, *(TVectorD*) libp->para[1].ref
, *(TVectorD*) libp->para[2].ref, *(TVectorD*) libp->para[3].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TGraphErrors));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_105_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraphErrors* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGraphErrors(*(TGraphErrors*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TGraphErrors(*(TGraphErrors*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TGraphErrors));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_105_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGraphErrors& obj = ((TGraphErrors*) G__getstructoffset())->operator=(*(TGraphErrors*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_105_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraphErrors* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGraphErrors((TH1*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGraphErrors((TH1*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TGraphErrors));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_105_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraphErrors* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraphErrors(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGraphErrors(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraphErrors((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGraphErrors((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraphErrors((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGraphErrors((const char*) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TGraphErrors));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_105_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGraphErrors::CalculateScanfFields((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_105_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGraphErrors*) G__getstructoffset())->SetPointError((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_105_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGraphErrors*) G__getstructoffset())->SetPointError((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_105_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGraphErrors::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_105_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGraphErrors::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_105_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGraphErrors::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_105_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGraphErrors::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_105_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGraphErrors*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_105_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGraphErrors::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_105_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGraphErrors::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_105_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGraphErrors::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_105_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGraphErrors::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGraphErrors G__TTGraphErrors;
static int G__G__Hist_105_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGraphErrors*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGraphErrors*) (soff+(sizeof(TGraphErrors)*i)))->~G__TTGraphErrors();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGraphErrors*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGraphErrors*) (soff))->~G__TTGraphErrors();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGraph2D */
static int G__G__Hist_106_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraph2D* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraph2D[n];
     } else {
       p = new((void*) gvp) TGraph2D[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraph2D;
     } else {
       p = new((void*) gvp) TGraph2D;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TGraph2D));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraph2D* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGraph2D((Int_t) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGraph2D((Int_t) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TGraph2D));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraph2D* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGraph2D(
(Int_t) G__int(libp->para[0]), (Int_t*) G__int(libp->para[1])
, (Int_t*) G__int(libp->para[2]), (Int_t*) G__int(libp->para[3]));
   } else {
     p = new((void*) gvp) TGraph2D(
(Int_t) G__int(libp->para[0]), (Int_t*) G__int(libp->para[1])
, (Int_t*) G__int(libp->para[2]), (Int_t*) G__int(libp->para[3]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TGraph2D));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraph2D* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGraph2D(
(Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3]));
   } else {
     p = new((void*) gvp) TGraph2D(
(Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TGraph2D));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraph2D* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGraph2D(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3]));
   } else {
     p = new((void*) gvp) TGraph2D(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TGraph2D));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraph2D* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGraph2D((TH2*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGraph2D((TH2*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TGraph2D));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraph2D* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 6
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGraph2D(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5]));
   } else {
     p = new((void*) gvp) TGraph2D(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TGraph2D));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraph2D* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraph2D(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGraph2D(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraph2D((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGraph2D((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraph2D((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGraph2D((const char*) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TGraph2D));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraph2D* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGraph2D(*(TGraph2D*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TGraph2D(*(TGraph2D*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TGraph2D));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGraph2D& obj = ((TGraph2D*) G__getstructoffset())->operator=(*(TGraph2D*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGraph2D*) G__getstructoffset())->DirectoryAutoAdd((TDirectory*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      {
         TFitResultPtr* pobj;
         TFitResultPtr xobj = ((TGraph2D*) G__getstructoffset())->Fit((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]));
         pobj = new TFitResultPtr(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 2:
      {
         TFitResultPtr* pobj;
         TFitResultPtr xobj = ((TGraph2D*) G__getstructoffset())->Fit((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
         pobj = new TFitResultPtr(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 1:
      {
         TFitResultPtr* pobj;
         TFitResultPtr xobj = ((TGraph2D*) G__getstructoffset())->Fit((const char*) G__int(libp->para[0]));
         pobj = new TFitResultPtr(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__G__Hist_106_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      {
         TFitResultPtr* pobj;
         TFitResultPtr xobj = ((TGraph2D*) G__getstructoffset())->Fit((TF2*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]));
         pobj = new TFitResultPtr(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 2:
      {
         TFitResultPtr* pobj;
         TFitResultPtr xobj = ((TGraph2D*) G__getstructoffset())->Fit((TF2*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
         pobj = new TFitResultPtr(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 1:
      {
         TFitResultPtr* pobj;
         TFitResultPtr xobj = ((TGraph2D*) G__getstructoffset())->Fit((TF2*) G__int(libp->para[0]));
         pobj = new TFitResultPtr(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__G__Hist_106_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGraph2D*) G__getstructoffset())->FitPanel();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGraph2D*) G__getstructoffset())->GetContourList((Double_t) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGraph2D*) G__getstructoffset())->GetDirectory());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGraph2D*) G__getstructoffset())->GetNpx());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGraph2D*) G__getstructoffset())->GetNpy());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 85, (long) ((TGraph2D*) G__getstructoffset())->GetHistogram((Option_t*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((TGraph2D*) G__getstructoffset())->GetHistogram());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGraph2D*) G__getstructoffset())->GetListOfFunctions());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGraph2D*) G__getstructoffset())->GetErrorX((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGraph2D*) G__getstructoffset())->GetErrorY((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGraph2D*) G__getstructoffset())->GetErrorZ((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGraph2D*) G__getstructoffset())->GetMargin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGraph2D*) G__getstructoffset())->GetXaxis());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGraph2D*) G__getstructoffset())->GetYaxis());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGraph2D*) G__getstructoffset())->GetZaxis());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGraph2D*) G__getstructoffset())->GetN());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TGraph2D*) G__getstructoffset())->GetX());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TGraph2D*) G__getstructoffset())->GetY());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TGraph2D*) G__getstructoffset())->GetZ());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TGraph2D*) G__getstructoffset())->GetEX());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TGraph2D*) G__getstructoffset())->GetEY());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TGraph2D*) G__getstructoffset())->GetEZ());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGraph2D*) G__getstructoffset())->GetXmax());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGraph2D*) G__getstructoffset())->GetXmin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGraph2D*) G__getstructoffset())->GetYmax());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGraph2D*) G__getstructoffset())->GetYmin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGraph2D*) G__getstructoffset())->GetZmax());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGraph2D*) G__getstructoffset())->GetZmin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGraph2D*) G__getstructoffset())->GetXmaxE());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGraph2D*) G__getstructoffset())->GetXminE());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGraph2D*) G__getstructoffset())->GetYmaxE());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGraph2D*) G__getstructoffset())->GetYminE());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGraph2D*) G__getstructoffset())->GetZmaxE());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGraph2D*) G__getstructoffset())->GetZminE());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TGraph2D*) G__getstructoffset())->Interpolate((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 85, (long) ((const TGraph2D*) G__getstructoffset())->Project((Option_t*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((const TGraph2D*) G__getstructoffset())->Project());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TGraph2D*) G__getstructoffset())->RemovePoint((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGraph2D*) G__getstructoffset())->Set((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGraph2D*) G__getstructoffset())->SetDirectory((TDirectory*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGraph2D*) G__getstructoffset())->SetHistogram((TH2*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGraph2D*) G__getstructoffset())->SetMargin((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGraph2D*) G__getstructoffset())->SetMargin();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGraph2D*) G__getstructoffset())->SetMarginBinsContent((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGraph2D*) G__getstructoffset())->SetMarginBinsContent();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGraph2D*) G__getstructoffset())->SetMaximum((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGraph2D*) G__getstructoffset())->SetMaximum();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGraph2D*) G__getstructoffset())->SetMinimum((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGraph2D*) G__getstructoffset())->SetMinimum();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGraph2D*) G__getstructoffset())->SetMaxIter((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGraph2D*) G__getstructoffset())->SetMaxIter();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGraph2D*) G__getstructoffset())->SetNpx((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGraph2D*) G__getstructoffset())->SetNpx();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGraph2D*) G__getstructoffset())->SetNpy((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGraph2D*) G__getstructoffset())->SetNpy();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGraph2D*) G__getstructoffset())->SetPoint((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGraph2D::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGraph2D::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGraph2D::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGraph2D::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGraph2D*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGraph2D::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGraph2D::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_83(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGraph2D::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_106_0_84(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGraph2D::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGraph2D G__TTGraph2D;
static int G__G__Hist_106_0_85(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGraph2D*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGraph2D*) (soff+(sizeof(TGraph2D)*i)))->~G__TTGraph2D();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGraph2D*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGraph2D*) (soff))->~G__TTGraph2D();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMultiGraph */
static int G__G__Hist_107_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMultiGraph* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMultiGraph[n];
     } else {
       p = new((void*) gvp) TMultiGraph[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMultiGraph;
     } else {
       p = new((void*) gvp) TMultiGraph;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TMultiGraph));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_107_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMultiGraph* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMultiGraph((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TMultiGraph((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TMultiGraph));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_107_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TMultiGraph*) G__getstructoffset())->Add((TGraph*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TMultiGraph*) G__getstructoffset())->Add((TGraph*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_107_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TMultiGraph*) G__getstructoffset())->Add((TMultiGraph*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TMultiGraph*) G__getstructoffset())->Add((TMultiGraph*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_107_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      {
         TFitResultPtr* pobj;
         TFitResultPtr xobj = ((TMultiGraph*) G__getstructoffset())->Fit((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]), (Axis_t) G__double(libp->para[3])
, (Axis_t) G__double(libp->para[4]));
         pobj = new TFitResultPtr(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 4:
      {
         TFitResultPtr* pobj;
         TFitResultPtr xobj = ((TMultiGraph*) G__getstructoffset())->Fit((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]), (Axis_t) G__double(libp->para[3]));
         pobj = new TFitResultPtr(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 3:
      {
         TFitResultPtr* pobj;
         TFitResultPtr xobj = ((TMultiGraph*) G__getstructoffset())->Fit((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]));
         pobj = new TFitResultPtr(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 2:
      {
         TFitResultPtr* pobj;
         TFitResultPtr xobj = ((TMultiGraph*) G__getstructoffset())->Fit((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
         pobj = new TFitResultPtr(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 1:
      {
         TFitResultPtr* pobj;
         TFitResultPtr xobj = ((TMultiGraph*) G__getstructoffset())->Fit((const char*) G__int(libp->para[0]));
         pobj = new TFitResultPtr(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__G__Hist_107_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      {
         TFitResultPtr* pobj;
         TFitResultPtr xobj = ((TMultiGraph*) G__getstructoffset())->Fit((TF1*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]), (Axis_t) G__double(libp->para[3])
, (Axis_t) G__double(libp->para[4]));
         pobj = new TFitResultPtr(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 4:
      {
         TFitResultPtr* pobj;
         TFitResultPtr xobj = ((TMultiGraph*) G__getstructoffset())->Fit((TF1*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]), (Axis_t) G__double(libp->para[3]));
         pobj = new TFitResultPtr(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 3:
      {
         TFitResultPtr* pobj;
         TFitResultPtr xobj = ((TMultiGraph*) G__getstructoffset())->Fit((TF1*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]));
         pobj = new TFitResultPtr(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 2:
      {
         TFitResultPtr* pobj;
         TFitResultPtr xobj = ((TMultiGraph*) G__getstructoffset())->Fit((TF1*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
         pobj = new TFitResultPtr(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 1:
      {
         TFitResultPtr* pobj;
         TFitResultPtr xobj = ((TMultiGraph*) G__getstructoffset())->Fit((TF1*) G__int(libp->para[0]));
         pobj = new TFitResultPtr(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__G__Hist_107_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMultiGraph*) G__getstructoffset())->FitPanel();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_107_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TMultiGraph*) G__getstructoffset())->GetGraphDrawOption((TGraph*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_107_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMultiGraph*) G__getstructoffset())->LeastSquareLinearFit((Int_t) G__int(libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2]), *(Int_t*) G__Intref(&libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_107_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMultiGraph*) G__getstructoffset())->LeastSquareFit((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_107_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMultiGraph*) G__getstructoffset())->InitPolynom((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_107_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMultiGraph*) G__getstructoffset())->InitExpo((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_107_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMultiGraph*) G__getstructoffset())->InitGaus((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_107_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMultiGraph*) G__getstructoffset())->IsInside((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_107_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMultiGraph*) G__getstructoffset())->GetHistogram());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_107_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMultiGraph*) G__getstructoffset())->GetFunction((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_107_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMultiGraph*) G__getstructoffset())->GetListOfGraphs());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_107_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TMultiGraph*) G__getstructoffset())->GetListOfFunctions());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_107_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMultiGraph*) G__getstructoffset())->GetListOfFunctions());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_107_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMultiGraph*) G__getstructoffset())->GetXaxis());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_107_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMultiGraph*) G__getstructoffset())->GetYaxis());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_107_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TMultiGraph*) G__getstructoffset())->SetMaximum((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TMultiGraph*) G__getstructoffset())->SetMaximum();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_107_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TMultiGraph*) G__getstructoffset())->SetMinimum((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TMultiGraph*) G__getstructoffset())->SetMinimum();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_107_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMultiGraph::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_107_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMultiGraph::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_107_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMultiGraph::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_107_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMultiGraph::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_107_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMultiGraph*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_107_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMultiGraph::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_107_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMultiGraph::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_107_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMultiGraph::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_107_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMultiGraph::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMultiGraph G__TTMultiGraph;
static int G__G__Hist_107_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMultiGraph*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMultiGraph*) (soff+(sizeof(TMultiGraph)*i)))->~G__TTMultiGraph();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMultiGraph*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMultiGraph*) (soff))->~G__TTMultiGraph();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TFitResult */
static int G__G__Hist_108_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TFitResult* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TFitResult((int) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TFitResult((int) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TFitResult[n];
       } else {
         p = new((void*) gvp) TFitResult[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TFitResult;
       } else {
         p = new((void*) gvp) TFitResult;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TFitResult));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_108_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TFitResult* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TFitResult(*(ROOT::Fit::FitResult*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TFitResult(*(ROOT::Fit::FitResult*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TFitResult));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_108_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixDSym* pobj;
         const TMatrixDSym xobj = ((const TFitResult*) G__getstructoffset())->GetCovarianceMatrix();
         pobj = new TMatrixDSym(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_108_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixDSym* pobj;
         const TMatrixDSym xobj = ((const TFitResult*) G__getstructoffset())->GetCorrelationMatrix();
         pobj = new TMatrixDSym(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_108_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TFitResult::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_108_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TFitResult::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_108_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TFitResult::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_108_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TFitResult::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_108_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TFitResult*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_108_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TFitResult::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_108_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TFitResult::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_108_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TFitResult::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_108_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TFitResult::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Hist_108_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TFitResult* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TFitResult(*(TFitResult*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TFitResult));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TFitResult G__TTFitResult;
static int G__G__Hist_108_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TFitResult*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TFitResult*) (soff+(sizeof(TFitResult)*i)))->~G__TTFitResult();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TFitResult*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TFitResult*) (soff))->~G__TTFitResult();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Hist_108_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TFitResult* dest = (TFitResult*) G__getstructoffset();
   *dest = *(TFitResult*) libp->para[0].ref;
   const TFitResult& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TFitResultPtr */
static int G__G__Hist_109_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TFitResultPtr* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TFitResultPtr((int) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TFitResultPtr((int) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TFitResultPtr[n];
       } else {
         p = new((void*) gvp) TFitResultPtr[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TFitResultPtr;
       } else {
         p = new((void*) gvp) TFitResultPtr;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TFitResultPtr));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_109_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TFitResultPtr* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TFitResultPtr((TFitResult*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TFitResultPtr((TFitResult*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TFitResultPtr));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_109_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TFitResultPtr* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TFitResultPtr(*(TFitResultPtr*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TFitResultPtr(*(TFitResultPtr*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TFitResultPtr));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_109_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TFitResultPtr*) G__getstructoffset())->operator int());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_109_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TFitResult& obj = ((const TFitResultPtr*) G__getstructoffset())->operator*();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_109_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TFitResultPtr*) G__getstructoffset())->operator->());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_109_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TFitResultPtr*) G__getstructoffset())->Get());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_109_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TFitResultPtr& obj = ((TFitResultPtr*) G__getstructoffset())->operator=(*(TFitResultPtr*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_109_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TFitResultPtr::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_109_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TFitResultPtr::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_109_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TFitResultPtr::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_109_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TFitResultPtr::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_109_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TFitResultPtr*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_109_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TFitResultPtr*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_109_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TFitResultPtr*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_109_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TFitResultPtr*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_109_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TFitResultPtr::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_109_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TFitResultPtr::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_109_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TFitResultPtr::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_109_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TFitResultPtr::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TFitResultPtr G__TTFitResultPtr;
static int G__G__Hist_109_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[] (TFitResultPtr*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TFitResultPtr*) (soff+(sizeof(TFitResultPtr)*i)))->~G__TTFitResultPtr();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TFitResultPtr*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TFitResultPtr*) (soff))->~G__TTFitResultPtr();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* ROOT::Fit */
static int G__G__Hist_112_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TFitResultPtr* pobj;
         TFitResultPtr xobj = ROOT::Fit::UnBinFit((ROOT::Fit::UnBinData*) G__int(libp->para[0]), (TF1*) G__int(libp->para[1])
, *(Foption_t*) libp->para[2].ref, *(ROOT::Math::MinimizerOptions*) libp->para[3].ref);
         pobj = new TFitResultPtr(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_112_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ROOT::Fit::FillData(*(ROOT::Fit::BinData*) libp->para[0].ref, (TH1*) G__int(libp->para[1])
, (TF1*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ROOT::Fit::FillData(*(ROOT::Fit::BinData*) libp->para[0].ref, (TH1*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_112_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ROOT::Fit::FillData(*(ROOT::Fit::SparseData*) libp->para[0].ref, (TH1*) G__int(libp->para[1])
, (TF1*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ROOT::Fit::FillData(*(ROOT::Fit::SparseData*) libp->para[0].ref, (TH1*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_112_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ROOT::Fit::FillData(*(ROOT::Fit::SparseData*) libp->para[0].ref, (THnSparse*) G__int(libp->para[1])
, (TF1*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ROOT::Fit::FillData(*(ROOT::Fit::SparseData*) libp->para[0].ref, (THnSparse*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_112_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ROOT::Fit::FillData(*(ROOT::Fit::BinData*) libp->para[0].ref, (THnSparse*) G__int(libp->para[1])
, (TF1*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ROOT::Fit::FillData(*(ROOT::Fit::BinData*) libp->para[0].ref, (THnSparse*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_112_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ROOT::Fit::FillData(*(ROOT::Fit::BinData*) libp->para[0].ref, (TGraph2D*) G__int(libp->para[1])
, (TF1*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ROOT::Fit::FillData(*(ROOT::Fit::BinData*) libp->para[0].ref, (TGraph2D*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_112_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ROOT::Fit::FillData(*(ROOT::Fit::BinData*) libp->para[0].ref, (TGraph*) G__int(libp->para[1])
, (TF1*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ROOT::Fit::FillData(*(ROOT::Fit::BinData*) libp->para[0].ref, (TGraph*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_112_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ROOT::Fit::FillData(*(ROOT::Fit::BinData*) libp->para[0].ref, (TMultiGraph*) G__int(libp->para[1])
, (TF1*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ROOT::Fit::FillData(*(ROOT::Fit::BinData*) libp->para[0].ref, (TMultiGraph*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_112_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ROOT::Fit::InitExpo(*(ROOT::Fit::BinData*) libp->para[0].ref, (TF1*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_112_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ROOT::Fit::InitGaus(*(ROOT::Fit::BinData*) libp->para[0].ref, (TF1*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_112_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ROOT::Fit::Init2DGaus(*(ROOT::Fit::BinData*) libp->para[0].ref, (TF1*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_112_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 103, (long) ROOT::Fit::GetConfidenceIntervals((TH1*) G__int(libp->para[0]), *(ROOT::Fit::FitResult*) libp->para[1].ref
, (TGraphErrors*) G__int(libp->para[2]), (double) G__double(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 103, (long) ROOT::Fit::GetConfidenceIntervals((TH1*) G__int(libp->para[0]), *(ROOT::Fit::FitResult*) libp->para[1].ref
, (TGraphErrors*) G__int(libp->para[2])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}


/* ROOT::Fit::FitResult */
static int G__G__Hist_113_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const ROOT::Fit::FitResult*) G__getstructoffset())->GetCovarianceMatrix<TMatrixDSym>(*(TMatrixTSym<double>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_113_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const ROOT::Fit::FitResult*) G__getstructoffset())->GetCorrelationMatrix<TMatrixDSym>(*(TMatrixTSym<double>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TAxis */
static int G__G__Hist_133_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TAxis* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TAxis[n];
     } else {
       p = new((void*) gvp) TAxis[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TAxis;
     } else {
       p = new((void*) gvp) TAxis;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TAxis));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TAxis* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TAxis(
(Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
   } else {
     p = new((void*) gvp) TAxis(
(Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TAxis));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TAxis* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TAxis((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TAxis((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TAxis));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TAxis* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TAxis(*(TAxis*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TAxis(*(TAxis*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TAxis));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TAxis*) G__getstructoffset())->CenterLabels((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TAxis*) G__getstructoffset())->CenterLabels();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TAxis*) G__getstructoffset())->CenterTitle((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TAxis*) G__getstructoffset())->CenterTitle();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 67, (long) ((TAxis*) G__getstructoffset())->ChooseTimeFormat((Double_t) G__double(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 67, (long) ((TAxis*) G__getstructoffset())->ChooseTimeFormat());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TAxis*) G__getstructoffset())->FindBin((Double_t) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TAxis*) G__getstructoffset())->FindBin((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TAxis*) G__getstructoffset())->FindFixBin((Double_t) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TAxis*) G__getstructoffset())->GetBinCenter((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TAxis*) G__getstructoffset())->GetBinCenterLog((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TAxis*) G__getstructoffset())->GetBinLabel((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TAxis*) G__getstructoffset())->GetBinLowEdge((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TAxis*) G__getstructoffset())->GetBinUpEdge((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TAxis*) G__getstructoffset())->GetBinWidth((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TAxis*) G__getstructoffset())->GetCenter((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TAxis*) G__getstructoffset())->GetCenterLabels());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TAxis*) G__getstructoffset())->GetCenterTitle());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TAxis*) G__getstructoffset())->GetLabels());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TAxis*) G__getstructoffset())->GetLowEdge((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TAxis*) G__getstructoffset())->GetMoreLogLabels());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TAxis*) G__getstructoffset())->GetNbins());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TAxis*) G__getstructoffset())->GetNoExponent());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TAxis*) G__getstructoffset())->GetDecimals());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TAxis*) G__getstructoffset())->GetParent());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TAxis*) G__getstructoffset())->GetRotateTitle());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TAxis*) G__getstructoffset())->GetTicks());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TAxis*) G__getstructoffset())->GetTimeDisplay());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TAxis*) G__getstructoffset())->GetTimeFormat());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TAxis*) G__getstructoffset())->GetTimeFormatOnly());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TAxis*) G__getstructoffset())->GetXbins());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TAxis*) G__getstructoffset())->GetFirst());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TAxis*) G__getstructoffset())->GetLast());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TAxis*) G__getstructoffset())->GetXmin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TAxis*) G__getstructoffset())->GetXmax());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TAxis*) G__getstructoffset())->ImportAttributes((TAxis*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TAxis*) G__getstructoffset())->IsVariableBinSize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TAxis*) G__getstructoffset())->LabelsOption((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TAxis*) G__getstructoffset())->LabelsOption();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TAxis*) G__getstructoffset())->RotateTitle((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TAxis*) G__getstructoffset())->RotateTitle();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TAxis*) G__getstructoffset())->Set((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TAxis*) G__getstructoffset())->Set((Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TAxis*) G__getstructoffset())->Set((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TAxis*) G__getstructoffset())->SetBinLabel((Int_t) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TAxis*) G__getstructoffset())->SetDefaults();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TAxis*) G__getstructoffset())->SetLimits((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TAxis*) G__getstructoffset())->SetMoreLogLabels((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TAxis*) G__getstructoffset())->SetMoreLogLabels();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TAxis*) G__getstructoffset())->SetNoExponent((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TAxis*) G__getstructoffset())->SetNoExponent();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TAxis*) G__getstructoffset())->SetDecimals((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TAxis*) G__getstructoffset())->SetDecimals();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TAxis*) G__getstructoffset())->SetParent((TObject*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TAxis*) G__getstructoffset())->SetRange((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TAxis*) G__getstructoffset())->SetRange((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TAxis*) G__getstructoffset())->SetRange();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TAxis*) G__getstructoffset())->SetRangeUser((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TAxis*) G__getstructoffset())->SetTicks((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TAxis*) G__getstructoffset())->SetTicks();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TAxis*) G__getstructoffset())->SetTimeDisplay((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TAxis*) G__getstructoffset())->SetTimeFormat((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TAxis*) G__getstructoffset())->SetTimeFormat();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TAxis*) G__getstructoffset())->SetTimeOffset((Double_t) G__double(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TAxis*) G__getstructoffset())->SetTimeOffset((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TAxis*) G__getstructoffset())->UnZoom();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TAxis*) G__getstructoffset())->ZoomOut((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TAxis*) G__getstructoffset())->ZoomOut((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TAxis*) G__getstructoffset())->ZoomOut();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TAxis::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TAxis::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TAxis::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TAxis::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TAxis*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TAxis::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TAxis::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TAxis::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_133_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TAxis::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TAxis G__TTAxis;
static int G__G__Hist_133_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TAxis*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TAxis*) (soff+(sizeof(TAxis)*i)))->~G__TTAxis();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TAxis*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TAxis*) (soff))->~G__TTAxis();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TBackCompFitter */
static int G__G__Hist_201_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TBackCompFitter* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBackCompFitter[n];
     } else {
       p = new((void*) gvp) TBackCompFitter[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBackCompFitter;
     } else {
       p = new((void*) gvp) TBackCompFitter;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TBackCompFitter));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_201_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TBackCompFitter* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TBackCompFitter(*((auto_ptr<ROOT::Fit::Fitter>*) G__int(libp->para[0])), *((auto_ptr<ROOT::Fit::FitData>*) G__int(libp->para[1])));
   } else {
     p = new((void*) gvp) TBackCompFitter(*((auto_ptr<ROOT::Fit::Fitter>*) G__int(libp->para[0])), *((auto_ptr<ROOT::Fit::FitData>*) G__int(libp->para[1])));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TBackCompFitter));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_201_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBackCompFitter*) G__getstructoffset())->SetMethodCall((TMethodCall*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_201_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Fit::FitConfig& obj = ((TBackCompFitter*) G__getstructoffset())->GetFitConfig();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_201_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Fit::FitResult& obj = ((const TBackCompFitter*) G__getstructoffset())->GetFitResult();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_201_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TBackCompFitter*) G__getstructoffset())->GetTFitResult());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_201_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Fit::FitData& obj = ((const TBackCompFitter*) G__getstructoffset())->GetFitData();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_201_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TBackCompFitter*) G__getstructoffset())->GetMinimizer());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_201_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TBackCompFitter*) G__getstructoffset())->GetObjFunction());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_201_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 103, (long) ((TBackCompFitter*) G__getstructoffset())->Scan((unsigned int) G__int(libp->para[0]), (TGraph*) G__int(libp->para[1])
, (double) G__double(libp->para[2]), (double) G__double(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 103, (long) ((TBackCompFitter*) G__getstructoffset())->Scan((unsigned int) G__int(libp->para[0]), (TGraph*) G__int(libp->para[1])
, (double) G__double(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 103, (long) ((TBackCompFitter*) G__getstructoffset())->Scan((unsigned int) G__int(libp->para[0]), (TGraph*) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_201_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 103, (long) ((TBackCompFitter*) G__getstructoffset())->Contour((unsigned int) G__int(libp->para[0]), (unsigned int) G__int(libp->para[1])
, (TGraph*) G__int(libp->para[2]), (double) G__double(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 103, (long) ((TBackCompFitter*) G__getstructoffset())->Contour((unsigned int) G__int(libp->para[0]), (unsigned int) G__int(libp->para[1])
, (TGraph*) G__int(libp->para[2])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_201_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBackCompFitter*) G__getstructoffset())->SetObjFunction((ROOT::Math::IMultiGenFunction*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_201_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBackCompFitter*) G__getstructoffset())->ReCreateMinimizer();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_201_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TBackCompFitter::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_201_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TBackCompFitter::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_201_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TBackCompFitter::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_201_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TBackCompFitter::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_201_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBackCompFitter*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_201_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TBackCompFitter::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_201_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TBackCompFitter::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_201_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TBackCompFitter::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_201_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TBackCompFitter::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Hist_201_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TBackCompFitter* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TBackCompFitter(*(TBackCompFitter*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TBackCompFitter));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TBackCompFitter G__TTBackCompFitter;
static int G__G__Hist_201_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TBackCompFitter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TBackCompFitter*) (soff+(sizeof(TBackCompFitter)*i)))->~G__TTBackCompFitter();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TBackCompFitter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TBackCompFitter*) (soff))->~G__TTBackCompFitter();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TBinomialEfficiencyFitter */
static int G__G__Hist_205_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TBinomialEfficiencyFitter* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBinomialEfficiencyFitter[n];
     } else {
       p = new((void*) gvp) TBinomialEfficiencyFitter[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBinomialEfficiencyFitter;
     } else {
       p = new((void*) gvp) TBinomialEfficiencyFitter;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TBinomialEfficiencyFitter));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_205_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TBinomialEfficiencyFitter* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TBinomialEfficiencyFitter((TH1*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TBinomialEfficiencyFitter((TH1*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TBinomialEfficiencyFitter));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_205_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBinomialEfficiencyFitter*) G__getstructoffset())->Set((TH1*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_205_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBinomialEfficiencyFitter*) G__getstructoffset())->SetPrecision((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_205_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 105, (long) ((TBinomialEfficiencyFitter*) G__getstructoffset())->Fit((TF1*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((TBinomialEfficiencyFitter*) G__getstructoffset())->Fit((TF1*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_205_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TBinomialEfficiencyFitter::GetFitter());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_205_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBinomialEfficiencyFitter*) G__getstructoffset())->ComputeFCN(*(Int_t*) G__Intref(&libp->para[0]), (Double_t*) G__int(libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_205_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TBinomialEfficiencyFitter::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_205_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TBinomialEfficiencyFitter::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_205_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TBinomialEfficiencyFitter::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_205_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TBinomialEfficiencyFitter::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_205_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBinomialEfficiencyFitter*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_205_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TBinomialEfficiencyFitter::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_205_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TBinomialEfficiencyFitter::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_205_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TBinomialEfficiencyFitter::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_205_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TBinomialEfficiencyFitter::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Hist_205_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TBinomialEfficiencyFitter* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TBinomialEfficiencyFitter(*(TBinomialEfficiencyFitter*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TBinomialEfficiencyFitter));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TBinomialEfficiencyFitter G__TTBinomialEfficiencyFitter;
static int G__G__Hist_205_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TBinomialEfficiencyFitter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TBinomialEfficiencyFitter*) (soff+(sizeof(TBinomialEfficiencyFitter)*i)))->~G__TTBinomialEfficiencyFitter();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TBinomialEfficiencyFitter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TBinomialEfficiencyFitter*) (soff))->~G__TTBinomialEfficiencyFitter();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Hist_205_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TBinomialEfficiencyFitter* dest = (TBinomialEfficiencyFitter*) G__getstructoffset();
   *dest = *(TBinomialEfficiencyFitter*) libp->para[0].ref;
   const TBinomialEfficiencyFitter& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TConfidenceLevel */
static int G__G__Hist_206_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TConfidenceLevel* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TConfidenceLevel[n];
     } else {
       p = new((void*) gvp) TConfidenceLevel[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TConfidenceLevel;
     } else {
       p = new((void*) gvp) TConfidenceLevel;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TConfidenceLevel));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_206_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TConfidenceLevel* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TConfidenceLevel((Int_t) G__int(libp->para[0]), (bool) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TConfidenceLevel((Int_t) 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 TConfidenceLevel((Int_t) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TConfidenceLevel((Int_t) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TConfidenceLevel));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_206_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TConfidenceLevel*) G__getstructoffset())->SetTSD((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_206_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TConfidenceLevel*) G__getstructoffset())->SetTSB((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_206_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TConfidenceLevel*) G__getstructoffset())->SetTSS((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_206_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TConfidenceLevel*) G__getstructoffset())->SetLRS((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_206_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TConfidenceLevel*) G__getstructoffset())->SetLRB((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_206_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TConfidenceLevel*) G__getstructoffset())->SetBtot((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_206_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TConfidenceLevel*) G__getstructoffset())->SetStot((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_206_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TConfidenceLevel*) G__getstructoffset())->SetDtot((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_206_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TConfidenceLevel*) G__getstructoffset())->GetStatistic());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_206_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TConfidenceLevel*) G__getstructoffset())->GetExpectedStatistic_b((Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TConfidenceLevel*) G__getstructoffset())->GetExpectedStatistic_b());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_206_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TConfidenceLevel*) G__getstructoffset())->GetExpectedStatistic_sb((Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TConfidenceLevel*) G__getstructoffset())->GetExpectedStatistic_sb());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_206_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TConfidenceLevel*) G__getstructoffset())->CLb((bool) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TConfidenceLevel*) G__getstructoffset())->CLb());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_206_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TConfidenceLevel*) G__getstructoffset())->CLsb((bool) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TConfidenceLevel*) G__getstructoffset())->CLsb());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_206_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TConfidenceLevel*) G__getstructoffset())->CLs((bool) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TConfidenceLevel*) G__getstructoffset())->CLs());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_206_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TConfidenceLevel*) G__getstructoffset())->GetExpectedCLb_sb((Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TConfidenceLevel*) G__getstructoffset())->GetExpectedCLb_sb());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_206_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TConfidenceLevel*) G__getstructoffset())->GetExpectedCLb_b((Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TConfidenceLevel*) G__getstructoffset())->GetExpectedCLb_b());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_206_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TConfidenceLevel*) G__getstructoffset())->GetExpectedCLsb_b((Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TConfidenceLevel*) G__getstructoffset())->GetExpectedCLsb_b());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_206_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TConfidenceLevel*) G__getstructoffset())->GetExpectedCLs_b((Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TConfidenceLevel*) G__getstructoffset())->GetExpectedCLs_b());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_206_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TConfidenceLevel*) G__getstructoffset())->GetAverageCLs());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_206_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TConfidenceLevel*) G__getstructoffset())->GetAverageCLsb());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_206_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TConfidenceLevel*) G__getstructoffset())->Get3sProbability());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_206_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TConfidenceLevel*) G__getstructoffset())->Get5sProbability());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_206_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TConfidenceLevel*) G__getstructoffset())->GetDtot());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_206_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TConfidenceLevel*) G__getstructoffset())->GetStot());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_206_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TConfidenceLevel*) G__getstructoffset())->GetBtot());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_206_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TConfidenceLevel::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_206_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TConfidenceLevel::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_206_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TConfidenceLevel::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_206_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TConfidenceLevel::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_206_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TConfidenceLevel*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_206_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TConfidenceLevel::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_206_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TConfidenceLevel::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_206_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TConfidenceLevel::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_206_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TConfidenceLevel::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Hist_206_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TConfidenceLevel* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TConfidenceLevel(*(TConfidenceLevel*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TConfidenceLevel));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TConfidenceLevel G__TTConfidenceLevel;
static int G__G__Hist_206_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TConfidenceLevel*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TConfidenceLevel*) (soff+(sizeof(TConfidenceLevel)*i)))->~G__TTConfidenceLevel();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TConfidenceLevel*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TConfidenceLevel*) (soff))->~G__TTConfidenceLevel();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Hist_206_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TConfidenceLevel* dest = (TConfidenceLevel*) G__getstructoffset();
   *dest = *(TConfidenceLevel*) libp->para[0].ref;
   const TConfidenceLevel& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGraphAsymmErrors */
static int G__G__Hist_213_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraphAsymmErrors* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraphAsymmErrors[n];
     } else {
       p = new((void*) gvp) TGraphAsymmErrors[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraphAsymmErrors;
     } else {
       p = new((void*) gvp) TGraphAsymmErrors;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TGraphAsymmErrors));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_213_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraphAsymmErrors* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGraphAsymmErrors((Int_t) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGraphAsymmErrors((Int_t) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TGraphAsymmErrors));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_213_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraphAsymmErrors* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraphAsymmErrors(
(Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3])
, (Float_t*) G__int(libp->para[4]), (Float_t*) G__int(libp->para[5])
, (Float_t*) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) TGraphAsymmErrors(
(Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3])
, (Float_t*) G__int(libp->para[4]), (Float_t*) G__int(libp->para[5])
, (Float_t*) G__int(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraphAsymmErrors(
(Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3])
, (Float_t*) G__int(libp->para[4]), (Float_t*) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGraphAsymmErrors(
(Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3])
, (Float_t*) G__int(libp->para[4]), (Float_t*) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraphAsymmErrors(
(Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3])
, (Float_t*) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGraphAsymmErrors(
(Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3])
, (Float_t*) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraphAsymmErrors(
(Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGraphAsymmErrors(
(Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraphAsymmErrors(
(Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGraphAsymmErrors(
(Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TGraphAsymmErrors));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_213_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraphAsymmErrors* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraphAsymmErrors(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5])
, (Double_t*) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) TGraphAsymmErrors(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5])
, (Double_t*) G__int(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraphAsymmErrors(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGraphAsymmErrors(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraphAsymmErrors(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGraphAsymmErrors(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraphAsymmErrors(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGraphAsymmErrors(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraphAsymmErrors(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGraphAsymmErrors(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TGraphAsymmErrors));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_213_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraphAsymmErrors* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 6
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGraphAsymmErrors(
*(TVectorF*) libp->para[0].ref, *(TVectorF*) libp->para[1].ref
, *(TVectorF*) libp->para[2].ref, *(TVectorF*) libp->para[3].ref
, *(TVectorF*) libp->para[4].ref, *(TVectorF*) libp->para[5].ref);
   } else {
     p = new((void*) gvp) TGraphAsymmErrors(
*(TVectorF*) libp->para[0].ref, *(TVectorF*) libp->para[1].ref
, *(TVectorF*) libp->para[2].ref, *(TVectorF*) libp->para[3].ref
, *(TVectorF*) libp->para[4].ref, *(TVectorF*) libp->para[5].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TGraphAsymmErrors));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_213_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraphAsymmErrors* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 6
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGraphAsymmErrors(
*(TVectorD*) libp->para[0].ref, *(TVectorD*) libp->para[1].ref
, *(TVectorD*) libp->para[2].ref, *(TVectorD*) libp->para[3].ref
, *(TVectorD*) libp->para[4].ref, *(TVectorD*) libp->para[5].ref);
   } else {
     p = new((void*) gvp) TGraphAsymmErrors(
*(TVectorD*) libp->para[0].ref, *(TVectorD*) libp->para[1].ref
, *(TVectorD*) libp->para[2].ref, *(TVectorD*) libp->para[3].ref
, *(TVectorD*) libp->para[4].ref, *(TVectorD*) libp->para[5].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TGraphAsymmErrors));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_213_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraphAsymmErrors* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGraphAsymmErrors(*(TGraphAsymmErrors*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TGraphAsymmErrors(*(TGraphAsymmErrors*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TGraphAsymmErrors));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_213_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGraphAsymmErrors& obj = ((TGraphAsymmErrors*) G__getstructoffset())->operator=(*(TGraphAsymmErrors*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_213_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraphAsymmErrors* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGraphAsymmErrors((TH1*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGraphAsymmErrors((TH1*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TGraphAsymmErrors));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_213_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraphAsymmErrors* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraphAsymmErrors(
(TH1*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGraphAsymmErrors(
(TH1*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraphAsymmErrors((TH1*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGraphAsymmErrors((TH1*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TGraphAsymmErrors));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_213_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TGraphAsymmErrors*) G__getstructoffset())->BayesDivide((TH1*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TGraphAsymmErrors*) G__getstructoffset())->BayesDivide((TH1*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_213_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TGraphAsymmErrors*) G__getstructoffset())->Divide((TH1*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TGraphAsymmErrors*) G__getstructoffset())->Divide((TH1*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_213_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGraphAsymmErrors*) G__getstructoffset())->SetPointError((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_213_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGraphAsymmErrors*) G__getstructoffset())->SetPointError((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_213_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGraphAsymmErrors*) G__getstructoffset())->SetPointEXlow((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_213_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGraphAsymmErrors*) G__getstructoffset())->SetPointEXhigh((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_213_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGraphAsymmErrors*) G__getstructoffset())->SetPointEYlow((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_213_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGraphAsymmErrors*) G__getstructoffset())->SetPointEYhigh((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_213_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGraphAsymmErrors::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_213_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGraphAsymmErrors::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_213_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGraphAsymmErrors::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_213_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGraphAsymmErrors::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_213_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGraphAsymmErrors*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_213_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGraphAsymmErrors::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_213_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGraphAsymmErrors::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_213_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGraphAsymmErrors::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_213_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGraphAsymmErrors::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGraphAsymmErrors G__TTGraphAsymmErrors;
static int G__G__Hist_213_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGraphAsymmErrors*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGraphAsymmErrors*) (soff+(sizeof(TGraphAsymmErrors)*i)))->~G__TTGraphAsymmErrors();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGraphAsymmErrors*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGraphAsymmErrors*) (soff))->~G__TTGraphAsymmErrors();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TH2 */
static int G__G__Hist_214_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH2* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH2(*(TH2*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TH2(*(TH2*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH2));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_214_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TH2*) G__getstructoffset())->Fill((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_214_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TH2*) G__getstructoffset())->Fill((Double_t) G__double(libp->para[0]), (const char*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_214_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TH2*) G__getstructoffset())->Fill((const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_214_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TH2*) G__getstructoffset())->Fill((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_214_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      ((TH2*) G__getstructoffset())->FillN((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TH2*) G__getstructoffset())->FillN((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_214_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 6:
      ((TH2*) G__getstructoffset())->FitSlicesX((TF1*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Option_t*) G__int(libp->para[4]), (TObjArray*) G__int(libp->para[5]));
      G__setnull(result7);
      break;
   case 5:
      ((TH2*) G__getstructoffset())->FitSlicesX((TF1*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Option_t*) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TH2*) G__getstructoffset())->FitSlicesX((TF1*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TH2*) G__getstructoffset())->FitSlicesX((TF1*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TH2*) G__getstructoffset())->FitSlicesX((TF1*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TH2*) G__getstructoffset())->FitSlicesX((TF1*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TH2*) G__getstructoffset())->FitSlicesX();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_214_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 6:
      ((TH2*) G__getstructoffset())->FitSlicesY((TF1*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Option_t*) G__int(libp->para[4]), (TObjArray*) G__int(libp->para[5]));
      G__setnull(result7);
      break;
   case 5:
      ((TH2*) G__getstructoffset())->FitSlicesY((TF1*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Option_t*) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TH2*) G__getstructoffset())->FitSlicesY((TF1*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TH2*) G__getstructoffset())->FitSlicesY((TF1*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TH2*) G__getstructoffset())->FitSlicesY((TF1*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TH2*) G__getstructoffset())->FitSlicesY((TF1*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TH2*) G__getstructoffset())->FitSlicesY();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_214_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 8:
      G__letdouble(result7, 100, (double) ((const TH2*) G__getstructoffset())->GetBinWithContent2(
(Double_t) G__double(libp->para[0]), *(Int_t*) G__Intref(&libp->para[1])
, *(Int_t*) G__Intref(&libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Double_t) G__double(libp->para[7])));
      break;
   case 7:
      G__letdouble(result7, 100, (double) ((const TH2*) G__getstructoffset())->GetBinWithContent2(
(Double_t) G__double(libp->para[0]), *(Int_t*) G__Intref(&libp->para[1])
, *(Int_t*) G__Intref(&libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6])));
      break;
   case 6:
      G__letdouble(result7, 100, (double) ((const TH2*) G__getstructoffset())->GetBinWithContent2((Double_t) G__double(libp->para[0]), *(Int_t*) G__Intref(&libp->para[1])
, *(Int_t*) G__Intref(&libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])));
      break;
   case 5:
      G__letdouble(result7, 100, (double) ((const TH2*) G__getstructoffset())->GetBinWithContent2((Double_t) G__double(libp->para[0]), *(Int_t*) G__Intref(&libp->para[1])
, *(Int_t*) G__Intref(&libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4])));
      break;
   case 4:
      G__letdouble(result7, 100, (double) ((const TH2*) G__getstructoffset())->GetBinWithContent2((Double_t) G__double(libp->para[0]), *(Int_t*) G__Intref(&libp->para[1])
, *(Int_t*) G__Intref(&libp->para[2]), (Int_t) G__int(libp->para[3])));
      break;
   case 3:
      G__letdouble(result7, 100, (double) ((const TH2*) G__getstructoffset())->GetBinWithContent2((Double_t) G__double(libp->para[0]), *(Int_t*) G__Intref(&libp->para[1])
, *(Int_t*) G__Intref(&libp->para[2])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_214_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letdouble(result7, 100, (double) ((const TH2*) G__getstructoffset())->GetCorrelationFactor((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((const TH2*) G__getstructoffset())->GetCorrelationFactor((Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TH2*) G__getstructoffset())->GetCorrelationFactor());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_214_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letdouble(result7, 100, (double) ((const TH2*) G__getstructoffset())->GetCovariance((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((const TH2*) G__getstructoffset())->GetCovariance((Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TH2*) G__getstructoffset())->GetCovariance());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_214_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TH2*) G__getstructoffset())->GetRandom2(*(Double_t*) G__Doubleref(&libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_214_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letdouble(result7, 100, (double) ((const TH2*) G__getstructoffset())->Integral((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Option_t*) G__int(libp->para[4])));
      break;
   case 4:
      G__letdouble(result7, 100, (double) ((const TH2*) G__getstructoffset())->Integral((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_214_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 7:
      G__letdouble(result7, 100, (double) ((const TH2*) G__getstructoffset())->Integral(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Option_t*) G__int(libp->para[6])));
      break;
   case 6:
      G__letdouble(result7, 100, (double) ((const TH2*) G__getstructoffset())->Integral((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_214_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 6:
      G__letdouble(result7, 100, (double) ((const TH2*) G__getstructoffset())->IntegralAndError((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, *(Double_t*) G__Doubleref(&libp->para[4]), (Option_t*) G__int(libp->para[5])));
      break;
   case 5:
      G__letdouble(result7, 100, (double) ((const TH2*) G__getstructoffset())->IntegralAndError((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, *(Double_t*) G__Doubleref(&libp->para[4])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_214_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 85, (long) ((TH2*) G__getstructoffset())->RebinX((Int_t) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TH2*) G__getstructoffset())->RebinX((Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((TH2*) G__getstructoffset())->RebinX());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_214_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 85, (long) ((TH2*) G__getstructoffset())->RebinY((Int_t) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TH2*) G__getstructoffset())->RebinY((Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((TH2*) G__getstructoffset())->RebinY());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_214_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 85, (long) ((TH2*) G__getstructoffset())->Rebin2D((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (const char*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((TH2*) G__getstructoffset())->Rebin2D((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TH2*) G__getstructoffset())->Rebin2D((Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((TH2*) G__getstructoffset())->Rebin2D());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_214_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 85, (long) ((const TH2*) G__getstructoffset())->ProfileX((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 85, (long) ((const TH2*) G__getstructoffset())->ProfileX((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((const TH2*) G__getstructoffset())->ProfileX((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((const TH2*) G__getstructoffset())->ProfileX((const char*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((const TH2*) G__getstructoffset())->ProfileX());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_214_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 85, (long) ((const TH2*) G__getstructoffset())->ProfileY((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 85, (long) ((const TH2*) G__getstructoffset())->ProfileY((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((const TH2*) G__getstructoffset())->ProfileY((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((const TH2*) G__getstructoffset())->ProfileY((const char*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((const TH2*) G__getstructoffset())->ProfileY());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_214_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 85, (long) ((const TH2*) G__getstructoffset())->ProjectionX((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 85, (long) ((const TH2*) G__getstructoffset())->ProjectionX((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((const TH2*) G__getstructoffset())->ProjectionX((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((const TH2*) G__getstructoffset())->ProjectionX((const char*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((const TH2*) G__getstructoffset())->ProjectionX());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_214_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 85, (long) ((const TH2*) G__getstructoffset())->ProjectionY((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 85, (long) ((const TH2*) G__getstructoffset())->ProjectionY((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((const TH2*) G__getstructoffset())->ProjectionY((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((const TH2*) G__getstructoffset())->ProjectionY((const char*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((const TH2*) G__getstructoffset())->ProjectionY());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_214_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TH2*) G__getstructoffset())->SetShowProjectionX((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_214_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TH2*) G__getstructoffset())->SetShowProjectionY((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_214_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TH2::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_214_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH2::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_214_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TH2::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_214_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TH2::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_214_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TH2*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_214_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH2::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_214_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TH2::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_214_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH2::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_214_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TH2::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TH2 G__TTH2;
static int G__G__Hist_214_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TH2*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TH2*) (soff+(sizeof(TH2)*i)))->~G__TTH2();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TH2*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TH2*) (soff))->~G__TTH2();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEfficiency */
static int G__G__Hist_215_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEfficiency* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEfficiency[n];
     } else {
       p = new((void*) gvp) TEfficiency[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEfficiency;
     } else {
       p = new((void*) gvp) TEfficiency;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TEfficiency));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEfficiency* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEfficiency(*(TH1*) libp->para[0].ref, *(TH1*) libp->para[1].ref);
   } else {
     p = new((void*) gvp) TEfficiency(*(TH1*) libp->para[0].ref, *(TH1*) libp->para[1].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TEfficiency));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEfficiency* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEfficiency(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3]));
   } else {
     p = new((void*) gvp) TEfficiency(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TEfficiency));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEfficiency* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 5
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEfficiency(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
   } else {
     p = new((void*) gvp) TEfficiency(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TEfficiency));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEfficiency* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 8
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEfficiency(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7]));
   } else {
     p = new((void*) gvp) TEfficiency(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TEfficiency));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEfficiency* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 6
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEfficiency(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5]));
   } else {
     p = new((void*) gvp) TEfficiency(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TEfficiency));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEfficiency* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 11
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEfficiency(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Int_t) G__int(libp->para[8]), (Double_t) G__double(libp->para[9])
, (Double_t) G__double(libp->para[10]));
   } else {
     p = new((void*) gvp) TEfficiency(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Int_t) G__int(libp->para[8]), (Double_t) G__double(libp->para[9])
, (Double_t) G__double(libp->para[10]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TEfficiency));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEfficiency* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 8
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEfficiency(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Double_t*) G__int(libp->para[7]));
   } else {
     p = new((void*) gvp) TEfficiency(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Double_t*) G__int(libp->para[7]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TEfficiency));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEfficiency* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEfficiency(*(TEfficiency*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TEfficiency(*(TEfficiency*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TEfficiency));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEfficiency*) G__getstructoffset())->Add(*(TEfficiency*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TEfficiency*) G__getstructoffset())->Fill((Bool_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TEfficiency*) G__getstructoffset())->Fill((Bool_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TEfficiency*) G__getstructoffset())->Fill((Bool_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 105, (long) ((const TEfficiency*) G__getstructoffset())->FindFixBin((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 105, (long) ((const TEfficiency*) G__getstructoffset())->FindFixBin((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((const TEfficiency*) G__getstructoffset())->FindFixBin((Double_t) G__double(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 105, (long) ((TEfficiency*) G__getstructoffset())->Fit((TF1*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((TEfficiency*) G__getstructoffset())->Fit((TF1*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TEfficiency*) G__getstructoffset())->GetBetaAlpha((Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TEfficiency*) G__getstructoffset())->GetBetaAlpha());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TEfficiency*) G__getstructoffset())->GetBetaBeta((Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TEfficiency*) G__getstructoffset())->GetBetaBeta());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEfficiency*) G__getstructoffset())->GetConfidenceLevel());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEfficiency*) G__getstructoffset())->GetCopyPassedHisto());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEfficiency*) G__getstructoffset())->GetCopyTotalHisto());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEfficiency*) G__getstructoffset())->GetDimension());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEfficiency*) G__getstructoffset())->GetDirectory());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEfficiency*) G__getstructoffset())->GetEfficiency((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEfficiency*) G__getstructoffset())->GetEfficiencyErrorLow((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEfficiency*) G__getstructoffset())->GetEfficiencyErrorUp((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 105, (long) ((const TEfficiency*) G__getstructoffset())->GetGlobalBin((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 105, (long) ((const TEfficiency*) G__getstructoffset())->GetGlobalBin((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((const TEfficiency*) G__getstructoffset())->GetGlobalBin((Int_t) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEfficiency*) G__getstructoffset())->GetPaintedGraph());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEfficiency*) G__getstructoffset())->GetPaintedHistogram());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEfficiency*) G__getstructoffset())->GetListOfFunctions());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEfficiency*) G__getstructoffset())->GetPassedHistogram());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEfficiency*) G__getstructoffset())->GetStatisticOption());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEfficiency*) G__getstructoffset())->GetTotalHistogram());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEfficiency*) G__getstructoffset())->GetWeight());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEfficiency*) G__getstructoffset())->Merge((TCollection*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEfficiency& obj = ((TEfficiency*) G__getstructoffset())->operator+=(*(TEfficiency*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEfficiency& obj = ((TEfficiency*) G__getstructoffset())->operator=(*(TEfficiency*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEfficiency*) G__getstructoffset())->SetBetaAlpha((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEfficiency*) G__getstructoffset())->SetBetaBeta((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEfficiency*) G__getstructoffset())->SetBetaBinParameters((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEfficiency*) G__getstructoffset())->SetConfidenceLevel((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEfficiency*) G__getstructoffset())->SetDirectory((TDirectory*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TEfficiency*) G__getstructoffset())->SetPassedEvents((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TEfficiency*) G__getstructoffset())->SetPassedHistogram(*(TH1*) libp->para[0].ref, (Option_t*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TEfficiency*) G__getstructoffset())->SetPosteriorMode((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TEfficiency*) G__getstructoffset())->SetPosteriorMode();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TEfficiency*) G__getstructoffset())->SetPosteriorAverage((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TEfficiency*) G__getstructoffset())->SetPosteriorAverage();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TEfficiency*) G__getstructoffset())->SetShortestInterval((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TEfficiency*) G__getstructoffset())->SetShortestInterval();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TEfficiency*) G__getstructoffset())->SetCentralInterval((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TEfficiency*) G__getstructoffset())->SetCentralInterval();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEfficiency*) G__getstructoffset())->SetStatisticOption((TEfficiency::EStatOption) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TEfficiency*) G__getstructoffset())->SetTotalEvents((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TEfficiency*) G__getstructoffset())->SetTotalHistogram(*(TH1*) libp->para[0].ref, (Option_t*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEfficiency*) G__getstructoffset())->SetWeight((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEfficiency*) G__getstructoffset())->UsesBayesianStat());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEfficiency*) G__getstructoffset())->UsesPosteriorMode());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEfficiency*) G__getstructoffset())->UsesShortestInterval());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEfficiency*) G__getstructoffset())->UsesPosteriorAverage());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEfficiency*) G__getstructoffset())->UsesCentralInterval());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TEfficiency::CheckBinning(*(TH1*) libp->para[0].ref, *(TH1*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 103, (long) TEfficiency::CheckConsistency(*(TH1*) libp->para[0].ref, *(TH1*) libp->para[1].ref
, (Option_t*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 103, (long) TEfficiency::CheckConsistency(*(TH1*) libp->para[0].ref, *(TH1*) libp->para[1].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 103, (long) TEfficiency::CheckEntries(*(TH1*) libp->para[0].ref, *(TH1*) libp->para[1].ref
, (Option_t*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 103, (long) TEfficiency::CheckEntries(*(TH1*) libp->para[0].ref, *(TH1*) libp->para[1].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 10:
      G__letdouble(result7, 100, (double) TEfficiency::Combine(
*(Double_t*) G__Doubleref(&libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])
, (Int_t) G__int(libp->para[2]), (const Int_t*) G__int(libp->para[3])
, (const Int_t*) G__int(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t*) G__int(libp->para[8]), (Option_t*) G__int(libp->para[9])));
      break;
   case 9:
      G__letdouble(result7, 100, (double) TEfficiency::Combine(
*(Double_t*) G__Doubleref(&libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])
, (Int_t) G__int(libp->para[2]), (const Int_t*) G__int(libp->para[3])
, (const Int_t*) G__int(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t*) G__int(libp->para[8])));
      break;
   case 8:
      G__letdouble(result7, 100, (double) TEfficiency::Combine(
*(Double_t*) G__Doubleref(&libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])
, (Int_t) G__int(libp->para[2]), (const Int_t*) G__int(libp->para[3])
, (const Int_t*) G__int(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])));
      break;
   case 7:
      G__letdouble(result7, 100, (double) TEfficiency::Combine(
*(Double_t*) G__Doubleref(&libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])
, (Int_t) G__int(libp->para[2]), (const Int_t*) G__int(libp->para[3])
, (const Int_t*) G__int(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 85, (long) TEfficiency::Combine((TCollection*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 85, (long) TEfficiency::Combine((TCollection*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) TEfficiency::Combine((TCollection*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) TEfficiency::Combine((TCollection*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) TEfficiency::AgrestiCoull((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Bool_t) G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) TEfficiency::ClopperPearson((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Bool_t) G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) TEfficiency::Normal((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Bool_t) G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) TEfficiency::Wilson((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Bool_t) G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) TEfficiency::FeldmanCousins((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Bool_t) G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TEfficiency::FeldmanCousinsInterval((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), *(Double_t*) G__Doubleref(&libp->para[3])
, *(Double_t*) G__Doubleref(&libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 7:
      G__letdouble(result7, 100, (double) TEfficiency::Bayesian(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Bool_t) G__int(libp->para[5])
, (Bool_t) G__int(libp->para[6])));
      break;
   case 6:
      G__letdouble(result7, 100, (double) TEfficiency::Bayesian((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Bool_t) G__int(libp->para[5])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) TEfficiency::BetaCentralInterval((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Bool_t) G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TEfficiency::BetaShortestInterval((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), *(Double_t*) G__Doubleref(&libp->para[3])
, *(Double_t*) G__Doubleref(&libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) TEfficiency::BetaMean((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) TEfficiency::BetaMode((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEfficiency::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEfficiency::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEfficiency::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEfficiency::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_86(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEfficiency*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_87(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEfficiency::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_88(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEfficiency::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_89(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEfficiency::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_215_0_90(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEfficiency::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEfficiency G__TTEfficiency;
static int G__G__Hist_215_0_91(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEfficiency*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEfficiency*) (soff+(sizeof(TEfficiency)*i)))->~G__TTEfficiency();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEfficiency*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEfficiency*) (soff))->~G__TTEfficiency();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TFormulaPrimitive */
static int G__G__Hist_227_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TFormulaPrimitive* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TFormulaPrimitive[n];
     } else {
       p = new((void*) gvp) TFormulaPrimitive[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TFormulaPrimitive;
     } else {
       p = new((void*) gvp) TFormulaPrimitive;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TFormulaPrimitive));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_227_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TFormulaPrimitive* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TFormulaPrimitive(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TFormulaPrimitive::GenFunc0) G__int(libp->para[2]));
   } else {
     p = new((void*) gvp) TFormulaPrimitive(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TFormulaPrimitive::GenFunc0) G__int(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TFormulaPrimitive));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_227_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TFormulaPrimitive* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TFormulaPrimitive(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TFormulaPrimitive::GenFuncG) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
   } else {
     p = new((void*) gvp) TFormulaPrimitive(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TFormulaPrimitive::GenFuncG) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TFormulaPrimitive));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_227_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TFormulaPrimitive* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TFormulaPrimitive(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, *(TFormulaPrimitive::TFunc0 *) G__int(libp->para[2]));
   } else {
     p = new((void*) gvp) TFormulaPrimitive(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, *(TFormulaPrimitive::TFunc0 *) G__int(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TFormulaPrimitive));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_227_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TFormulaPrimitive::AddFormula((TFormulaPrimitive*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_227_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TFormulaPrimitive::FindFormula((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_227_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TFormulaPrimitive::FindFormula((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_227_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TFormulaPrimitive::FindFormula((const char*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_227_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TFormulaPrimitive*) G__getstructoffset())->Eval((Double_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_227_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TFormulaPrimitive*) G__getstructoffset())->Eval((TObject*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_227_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TFormulaPrimitive*) G__getstructoffset())->Eval((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_227_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TFormulaPrimitive::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_227_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TFormulaPrimitive::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_227_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TFormulaPrimitive::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_227_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TFormulaPrimitive::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_227_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TFormulaPrimitive*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_227_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TFormulaPrimitive::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_227_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TFormulaPrimitive::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_227_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TFormulaPrimitive::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_227_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TFormulaPrimitive::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TFormulaPrimitive G__TTFormulaPrimitive;
static int G__G__Hist_227_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TFormulaPrimitive*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TFormulaPrimitive*) (soff+(sizeof(TFormulaPrimitive)*i)))->~G__TTFormulaPrimitive();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TFormulaPrimitive*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TFormulaPrimitive*) (soff))->~G__TTFormulaPrimitive();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TFormula */
static int G__G__Hist_229_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TFormula* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TFormula[n];
     } else {
       p = new((void*) gvp) TFormula[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TFormula;
     } else {
       p = new((void*) gvp) TFormula;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TFormula));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_229_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TFormula* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TFormula((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TFormula((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TFormula));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_229_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TFormula* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TFormula(*(TFormula*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TFormula(*(TFormula*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TFormula));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_229_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TFormula& obj = ((TFormula*) G__getstructoffset())->operator=(*(TFormula*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_229_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TFormula*) G__getstructoffset())->Optimize();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_229_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TFormula*) G__getstructoffset())->Analyze((const char*) G__int(libp->para[0]), *(Int_t*) G__Intref(&libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TFormula*) G__getstructoffset())->Analyze((const char*) G__int(libp->para[0]), *(Int_t*) G__Intref(&libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_229_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 103, (long) ((TFormula*) G__getstructoffset())->AnalyzeFunction(*(TString*) libp->para[0].ref, *(Int_t*) G__Intref(&libp->para[1])
, (Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 103, (long) ((TFormula*) G__getstructoffset())->AnalyzeFunction(*(TString*) libp->para[0].ref, *(Int_t*) G__Intref(&libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_229_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 105, (long) ((TFormula*) G__getstructoffset())->Compile((const char*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 105, (long) ((TFormula*) G__getstructoffset())->Compile());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_229_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((TFormula*) G__getstructoffset())->DefinedString((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_229_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TFormula*) G__getstructoffset())->DefinedValue((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_229_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TFormula*) G__getstructoffset())->DefinedVariable(*(TString*) libp->para[0].ref, *(Int_t*) G__Intref(&libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_229_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letdouble(result7, 100, (double) ((const TFormula*) G__getstructoffset())->Eval((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])));
      break;
   case 3:
      G__letdouble(result7, 100, (double) ((const TFormula*) G__getstructoffset())->Eval((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2])));
      break;
   case 2:
      G__letdouble(result7, 100, (double) ((const TFormula*) G__getstructoffset())->Eval((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((const TFormula*) G__getstructoffset())->Eval((Double_t) G__double(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_229_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letdouble(result7, 100, (double) ((TFormula*) G__getstructoffset())->EvalParOld((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((TFormula*) G__getstructoffset())->EvalParOld((Double_t*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_229_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letdouble(result7, 100, (double) ((TFormula*) G__getstructoffset())->EvalPar((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((TFormula*) G__getstructoffset())->EvalPar((Double_t*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_229_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TFormula*) G__getstructoffset())->GetLinearPart((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_229_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TFormula*) G__getstructoffset())->GetNdim());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_229_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TFormula*) G__getstructoffset())->GetNpar());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_229_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TFormula*) G__getstructoffset())->GetNumber());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_229_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      {
         const TString* pobj;
         const TString xobj = ((const TFormula*) G__getstructoffset())->GetExpFormula((Option_t*) G__int(libp->para[0]));
         pobj = new TString(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 0:
      {
         const TString* pobj;
         const TString xobj = ((const TFormula*) G__getstructoffset())->GetExpFormula();
         pobj = new TString(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__G__Hist_229_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TFormula*) G__getstructoffset())->GetParameter((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_229_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TFormula*) G__getstructoffset())->GetParameter((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_229_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TFormula*) G__getstructoffset())->GetParameters());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_229_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TFormula*) G__getstructoffset())->GetParameters((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_229_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TFormula*) G__getstructoffset())->GetParName((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_229_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TFormula*) G__getstructoffset())->GetParNumber((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_229_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TFormula*) G__getstructoffset())->IsLinear());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_229_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TFormula*) G__getstructoffset())->IsNormalized());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_229_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TFormula*) G__getstructoffset())->ProcessLinear(*(TString*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_229_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TFormula*) G__getstructoffset())->SetNumber((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_229_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TFormula*) G__getstructoffset())->SetParameter((const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_229_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TFormula*) G__getstructoffset())->SetParameter((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_229_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TFormula*) G__getstructoffset())->SetParameters((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_229_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 11:
      ((TFormula*) G__getstructoffset())->SetParameters(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]), (Double_t) G__double(libp->para[9])
, (Double_t) G__double(libp->para[10]));
      G__setnull(result7);
      break;
   case 10:
      ((TFormula*) G__getstructoffset())->SetParameters(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]), (Double_t) G__double(libp->para[9]));
      G__setnull(result7);
      break;
   case 9:
      ((TFormula*) G__getstructoffset())->SetParameters(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]));
      G__setnull(result7);
      break;
   case 8:
      ((TFormula*) G__getstructoffset())->SetParameters(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7]));
      G__setnull(result7);
      break;
   case 7:
      ((TFormula*) G__getstructoffset())->SetParameters(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]));
      G__setnull(result7);
      break;
   case 6:
      ((TFormula*) G__getstructoffset())->SetParameters((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
      G__setnull(result7);
      break;
   case 5:
      ((TFormula*) G__getstructoffset())->SetParameters((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TFormula*) G__getstructoffset())->SetParameters((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TFormula*) G__getstructoffset())->SetParameters((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TFormula*) G__getstructoffset())->SetParameters((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_229_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TFormula*) G__getstructoffset())->SetParName((Int_t) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_229_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 11:
      ((TFormula*) G__getstructoffset())->SetParNames(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (const char*) G__int(libp->para[6]), (const char*) G__int(libp->para[7])
, (const char*) G__int(libp->para[8]), (const char*) G__int(libp->para[9])
, (const char*) G__int(libp->para[10]));
      G__setnull(result7);
      break;
   case 10:
      ((TFormula*) G__getstructoffset())->SetParNames(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (const char*) G__int(libp->para[6]), (const char*) G__int(libp->para[7])
, (const char*) G__int(libp->para[8]), (const char*) G__int(libp->para[9]));
      G__setnull(result7);
      break;
   case 9:
      ((TFormula*) G__getstructoffset())->SetParNames(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (const char*) G__int(libp->para[6]), (const char*) G__int(libp->para[7])
, (const char*) G__int(libp->para[8]));
      G__setnull(result7);
      break;
   case 8:
      ((TFormula*) G__getstructoffset())->SetParNames(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (const char*) G__int(libp->para[6]), (const char*) G__int(libp->para[7]));
      G__setnull(result7);
      break;
   case 7:
      ((TFormula*) G__getstructoffset())->SetParNames(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (const char*) G__int(libp->para[6]));
      G__setnull(result7);
      break;
   case 6:
      ((TFormula*) G__getstructoffset())->SetParNames((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (const char*) G__int(libp->para[5]));
      G__setnull(result7);
      break;
   case 5:
      ((TFormula*) G__getstructoffset())->SetParNames((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TFormula*) G__getstructoffset())->SetParNames((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TFormula*) G__getstructoffset())->SetParNames((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TFormula*) G__getstructoffset())->SetParNames((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TFormula*) G__getstructoffset())->SetParNames((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TFormula*) G__getstructoffset())->SetParNames();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_229_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TFormula*) G__getstructoffset())->Update();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_229_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      TFormula::SetMaxima((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      TFormula::SetMaxima((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      TFormula::SetMaxima((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      TFormula::SetMaxima();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_229_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TFormula::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_229_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TFormula::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_229_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TFormula::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_229_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TFormula::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_229_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TFormula*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_229_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TFormula::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_229_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TFormula::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_229_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TFormula::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_229_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TFormula::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TFormula G__TTFormula;
static int G__G__Hist_229_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TFormula*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TFormula*) (soff+(sizeof(TFormula)*i)))->~G__TTFormula();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TFormula*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TFormula*) (soff))->~G__TTFormula();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TF12 */
static int G__G__Hist_235_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TF12* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TF12[n];
     } else {
       p = new((void*) gvp) TF12[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TF12;
     } else {
       p = new((void*) gvp) TF12;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TF12));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_235_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TF12* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TF12(
(const char*) G__int(libp->para[0]), (TF2*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Option_t*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TF12(
(const char*) G__int(libp->para[0]), (TF2*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Option_t*) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TF12(
(const char*) G__int(libp->para[0]), (TF2*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]));
     } else {
       p = new((void*) gvp) TF12(
(const char*) G__int(libp->para[0]), (TF2*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TF12));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_235_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TF12* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TF12(*(TF12*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TF12(*(TF12*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TF12));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_235_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TF12*) G__getstructoffset())->GetXY());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_235_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TF12*) G__getstructoffset())->SetXY((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_235_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TF12::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_235_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TF12::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_235_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TF12::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_235_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TF12::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_235_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TF12*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_235_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TF12::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_235_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TF12::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_235_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TF12::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_235_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TF12::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TF12 G__TTF12;
static int G__G__Hist_235_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TF12*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TF12*) (soff+(sizeof(TF12)*i)))->~G__TTF12();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TF12*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TF12*) (soff))->~G__TTF12();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TF3 */
static int G__G__Hist_236_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TF3* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TF3[n];
     } else {
       p = new((void*) gvp) TF3[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TF3;
     } else {
       p = new((void*) gvp) TF3;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TF3));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_236_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TF3* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 8:
     //m: 8
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TF3(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7]));
     } else {
       p = new((void*) gvp) TF3(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7]));
     }
     break;
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TF3(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]));
     } else {
       p = new((void*) gvp) TF3(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TF3(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
     } else {
       p = new((void*) gvp) TF3(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TF3(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
     } else {
       p = new((void*) gvp) TF3(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TF3(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
     } else {
       p = new((void*) gvp) TF3(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TF3(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]));
     } else {
       p = new((void*) gvp) TF3(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TF3((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TF3((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TF3));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_236_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TF3* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 9:
     //m: 9
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TF3(
(const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Int_t) G__int(libp->para[8]));
     } else {
       p = new((void*) gvp) TF3(
(const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Int_t) G__int(libp->para[8]));
     }
     break;
   case 8:
     //m: 8
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TF3(
(const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7]));
     } else {
       p = new((void*) gvp) TF3(
(const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7]));
     }
     break;
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TF3(
(const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]));
     } else {
       p = new((void*) gvp) TF3(
(const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TF3(
(const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
     } else {
       p = new((void*) gvp) TF3(
(const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TF3(
(const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
     } else {
       p = new((void*) gvp) TF3(
(const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TF3(
(const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
     } else {
       p = new((void*) gvp) TF3(
(const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TF3(
(const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]));
     } else {
       p = new((void*) gvp) TF3(
(const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TF3((const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TF3((const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TF3));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_236_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TF3* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 9:
     //m: 9
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TF3(
(const char*) G__int(libp->para[0]), *((ROOT::Math::ParamFunctor*) G__int(libp->para[1]))
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Int_t) G__int(libp->para[8]));
     } else {
       p = new((void*) gvp) TF3(
(const char*) G__int(libp->para[0]), *((ROOT::Math::ParamFunctor*) G__int(libp->para[1]))
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Int_t) G__int(libp->para[8]));
     }
     break;
   case 8:
     //m: 8
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TF3(
(const char*) G__int(libp->para[0]), *((ROOT::Math::ParamFunctor*) G__int(libp->para[1]))
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7]));
     } else {
       p = new((void*) gvp) TF3(
(const char*) G__int(libp->para[0]), *((ROOT::Math::ParamFunctor*) G__int(libp->para[1]))
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7]));
     }
     break;
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TF3(
(const char*) G__int(libp->para[0]), *((ROOT::Math::ParamFunctor*) G__int(libp->para[1]))
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]));
     } else {
       p = new((void*) gvp) TF3(
(const char*) G__int(libp->para[0]), *((ROOT::Math::ParamFunctor*) G__int(libp->para[1]))
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TF3(
(const char*) G__int(libp->para[0]), *((ROOT::Math::ParamFunctor*) G__int(libp->para[1]))
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
     } else {
       p = new((void*) gvp) TF3(
(const char*) G__int(libp->para[0]), *((ROOT::Math::ParamFunctor*) G__int(libp->para[1]))
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TF3(
(const char*) G__int(libp->para[0]), *((ROOT::Math::ParamFunctor*) G__int(libp->para[1]))
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
     } else {
       p = new((void*) gvp) TF3(
(const char*) G__int(libp->para[0]), *((ROOT::Math::ParamFunctor*) G__int(libp->para[1]))
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TF3(
(const char*) G__int(libp->para[0]), *((ROOT::Math::ParamFunctor*) G__int(libp->para[1]))
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
     } else {
       p = new((void*) gvp) TF3(
(const char*) G__int(libp->para[0]), *((ROOT::Math::ParamFunctor*) G__int(libp->para[1]))
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TF3(
(const char*) G__int(libp->para[0]), *((ROOT::Math::ParamFunctor*) G__int(libp->para[1]))
, (Double_t) G__double(libp->para[2]));
     } else {
       p = new((void*) gvp) TF3(
(const char*) G__int(libp->para[0]), *((ROOT::Math::ParamFunctor*) G__int(libp->para[1]))
, (Double_t) G__double(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TF3((const char*) G__int(libp->para[0]), *((ROOT::Math::ParamFunctor*) G__int(libp->para[1])));
     } else {
       p = new((void*) gvp) TF3((const char*) G__int(libp->para[0]), *((ROOT::Math::ParamFunctor*) G__int(libp->para[1])));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TF3));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_236_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TF3* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 10
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TF3(
(const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Int_t) G__int(libp->para[8]), (const char*) G__int(libp->para[9]));
   } else {
     p = new((void*) gvp) TF3(
(const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Int_t) G__int(libp->para[8]), (const char*) G__int(libp->para[9]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TF3));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_236_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TF3* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 12:
     //m: 12
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TF3(
(const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (void*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]), (Int_t) G__int(libp->para[9])
, (const char*) G__int(libp->para[10]), (const char*) G__int(libp->para[11]));
     } else {
       p = new((void*) gvp) TF3(
(const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (void*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]), (Int_t) G__int(libp->para[9])
, (const char*) G__int(libp->para[10]), (const char*) G__int(libp->para[11]));
     }
     break;
   case 11:
     //m: 11
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TF3(
(const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (void*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]), (Int_t) G__int(libp->para[9])
, (const char*) G__int(libp->para[10]));
     } else {
       p = new((void*) gvp) TF3(
(const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (void*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]), (Int_t) G__int(libp->para[9])
, (const char*) G__int(libp->para[10]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TF3));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_236_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TF3* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TF3(*(TF3*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TF3(*(TF3*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TF3));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_236_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TF3& obj = ((TF3*) G__getstructoffset())->operator=(*(TF3*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_236_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TF3*) G__getstructoffset())->GetMinimumXYZ(*(Double_t*) G__Doubleref(&libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_236_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TF3*) G__getstructoffset())->GetNpz());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_236_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TF3*) G__getstructoffset())->GetRandom3(*(Double_t*) G__Doubleref(&libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_236_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TF3*) G__getstructoffset())->GetZmin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_236_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TF3*) G__getstructoffset())->GetZmax());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_236_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TF3*) G__getstructoffset())->SetClippingBoxOff();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_236_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TF3*) G__getstructoffset())->SetClippingBoxOn((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TF3*) G__getstructoffset())->SetClippingBoxOn((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TF3*) G__getstructoffset())->SetClippingBoxOn((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TF3*) G__getstructoffset())->SetClippingBoxOn();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_236_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TF3*) G__getstructoffset())->SetNpz((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TF3*) G__getstructoffset())->SetNpz();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_236_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 10:
      G__letdouble(result7, 100, (double) ((TF3*) G__getstructoffset())->Moment3(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]), (Double_t) G__double(libp->para[9])));
      break;
   case 9:
      G__letdouble(result7, 100, (double) ((TF3*) G__getstructoffset())->Moment3(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_236_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 10:
      G__letdouble(result7, 100, (double) ((TF3*) G__getstructoffset())->CentralMoment3(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]), (Double_t) G__double(libp->para[9])));
      break;
   case 9:
      G__letdouble(result7, 100, (double) ((TF3*) G__getstructoffset())->CentralMoment3(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_236_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 7:
      G__letdouble(result7, 100, (double) ((TF3*) G__getstructoffset())->Mean3X(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6])));
      break;
   case 6:
      G__letdouble(result7, 100, (double) ((TF3*) G__getstructoffset())->Mean3X((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_236_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 7:
      G__letdouble(result7, 100, (double) ((TF3*) G__getstructoffset())->Mean3Y(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6])));
      break;
   case 6:
      G__letdouble(result7, 100, (double) ((TF3*) G__getstructoffset())->Mean3Y((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_236_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 7:
      G__letdouble(result7, 100, (double) ((TF3*) G__getstructoffset())->Mean3Z(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6])));
      break;
   case 6:
      G__letdouble(result7, 100, (double) ((TF3*) G__getstructoffset())->Mean3Z((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_236_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 7:
      G__letdouble(result7, 100, (double) ((TF3*) G__getstructoffset())->Variance3X(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6])));
      break;
   case 6:
      G__letdouble(result7, 100, (double) ((TF3*) G__getstructoffset())->Variance3X((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_236_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 7:
      G__letdouble(result7, 100, (double) ((TF3*) G__getstructoffset())->Variance3Y(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6])));
      break;
   case 6:
      G__letdouble(result7, 100, (double) ((TF3*) G__getstructoffset())->Variance3Y((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_236_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 7:
      G__letdouble(result7, 100, (double) ((TF3*) G__getstructoffset())->Variance3Z(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6])));
      break;
   case 6:
      G__letdouble(result7, 100, (double) ((TF3*) G__getstructoffset())->Variance3Z((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_236_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 7:
      G__letdouble(result7, 100, (double) ((TF3*) G__getstructoffset())->Covariance3XY(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6])));
      break;
   case 6:
      G__letdouble(result7, 100, (double) ((TF3*) G__getstructoffset())->Covariance3XY((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_236_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 7:
      G__letdouble(result7, 100, (double) ((TF3*) G__getstructoffset())->Covariance3XZ(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6])));
      break;
   case 6:
      G__letdouble(result7, 100, (double) ((TF3*) G__getstructoffset())->Covariance3XZ((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_236_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 7:
      G__letdouble(result7, 100, (double) ((TF3*) G__getstructoffset())->Covariance3YZ(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6])));
      break;
   case 6:
      G__letdouble(result7, 100, (double) ((TF3*) G__getstructoffset())->Covariance3YZ((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_236_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TF3::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_236_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TF3::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_236_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TF3::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_236_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TF3::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_236_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TF3*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_236_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TF3::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_236_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TF3::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_236_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TF3::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_236_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TF3::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TF3 G__TTF3;
static int G__G__Hist_236_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TF3*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TF3*) (soff+(sizeof(TF3)*i)))->~G__TTF3();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TF3*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TF3*) (soff))->~G__TTF3();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TFractionFitter */
static int G__G__Hist_272_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TFractionFitter* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TFractionFitter[n];
     } else {
       p = new((void*) gvp) TFractionFitter[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TFractionFitter;
     } else {
       p = new((void*) gvp) TFractionFitter;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TFractionFitter));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_272_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TFractionFitter* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TFractionFitter((TH1*) G__int(libp->para[0]), (TObjArray*) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TFractionFitter((TH1*) G__int(libp->para[0]), (TObjArray*) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TFractionFitter));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_272_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TFractionFitter*) G__getstructoffset())->GetFitter());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_272_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TFractionFitter*) G__getstructoffset())->ErrorAnalysis((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_272_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TFractionFitter*) G__getstructoffset())->SetRangeX((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_272_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TFractionFitter*) G__getstructoffset())->ReleaseRangeX();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_272_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TFractionFitter*) G__getstructoffset())->SetRangeY((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_272_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TFractionFitter*) G__getstructoffset())->ReleaseRangeY();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_272_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TFractionFitter*) G__getstructoffset())->SetRangeZ((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_272_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TFractionFitter*) G__getstructoffset())->ReleaseRangeZ();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_272_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TFractionFitter*) G__getstructoffset())->Constrain((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_272_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TFractionFitter*) G__getstructoffset())->UnConstrain((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_272_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TFractionFitter*) G__getstructoffset())->SetData((TH1*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_272_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TFractionFitter*) G__getstructoffset())->SetMC((Int_t) G__int(libp->para[0]), (TH1*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_272_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TFractionFitter*) G__getstructoffset())->SetWeight((Int_t) G__int(libp->para[0]), (TH1*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_272_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TFractionFitter*) G__getstructoffset())->Fit());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_272_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TFractionFitter*) G__getstructoffset())->GetResult((Int_t) G__int(libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_272_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TFractionFitter*) G__getstructoffset())->GetPlot());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_272_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TFractionFitter*) G__getstructoffset())->GetChisquare());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_272_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TFractionFitter*) G__getstructoffset())->GetNDF());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_272_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TFractionFitter*) G__getstructoffset())->GetProb());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_272_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TFractionFitter*) G__getstructoffset())->GetMCPrediction((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_272_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TFractionFitter::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_272_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TFractionFitter::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_272_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TFractionFitter::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_272_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TFractionFitter::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_272_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TFractionFitter*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_272_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TFractionFitter::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_272_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TFractionFitter::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_272_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TFractionFitter::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_272_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TFractionFitter::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TFractionFitter G__TTFractionFitter;
static int G__G__Hist_272_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TFractionFitter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TFractionFitter*) (soff+(sizeof(TFractionFitter)*i)))->~G__TTFractionFitter();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TFractionFitter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TFractionFitter*) (soff))->~G__TTFractionFitter();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TVirtualHistPainter */
static int G__G__Hist_273_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualHistPainter*) G__getstructoffset())->DrawPanel();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_273_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TVirtualHistPainter*) G__getstructoffset())->GetContourList((Double_t) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_273_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TVirtualHistPainter*) G__getstructoffset())->GetStack());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_273_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TVirtualHistPainter*) G__getstructoffset())->IsInside((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_273_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TVirtualHistPainter*) G__getstructoffset())->IsInside((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_273_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualHistPainter*) G__getstructoffset())->PaintStat((Int_t) G__int(libp->para[0]), (TF1*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_273_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualHistPainter*) G__getstructoffset())->ProcessMessage((const char*) G__int(libp->para[0]), (TObject*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_273_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualHistPainter*) G__getstructoffset())->SetHistogram((TH1*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_273_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualHistPainter*) G__getstructoffset())->SetStack((TList*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_273_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TVirtualHistPainter*) G__getstructoffset())->MakeCuts((char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_273_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualHistPainter*) G__getstructoffset())->SetShowProjection((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_273_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TVirtualHistPainter::HistPainter((TH1*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_273_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TVirtualHistPainter::SetPainter((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_273_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TVirtualHistPainter::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_273_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TVirtualHistPainter::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_273_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TVirtualHistPainter::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_273_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TVirtualHistPainter::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_273_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualHistPainter*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_273_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TVirtualHistPainter::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_273_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TVirtualHistPainter::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_273_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TVirtualHistPainter::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_273_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TVirtualHistPainter::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TVirtualHistPainter G__TTVirtualHistPainter;
static int G__G__Hist_273_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TVirtualHistPainter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TVirtualHistPainter*) (soff+(sizeof(TVirtualHistPainter)*i)))->~G__TTVirtualHistPainter();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TVirtualHistPainter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TVirtualHistPainter*) (soff))->~G__TTVirtualHistPainter();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Hist_273_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TVirtualHistPainter* dest = (TVirtualHistPainter*) G__getstructoffset();
   *dest = *(TVirtualHistPainter*) libp->para[0].ref;
   const TVirtualHistPainter& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TH2D */
static int G__G__Hist_274_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH2D* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TH2D[n];
     } else {
       p = new((void*) gvp) TH2D[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TH2D;
     } else {
       p = new((void*) gvp) TH2D;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH2D));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_274_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH2D* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 8
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH2D(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7]));
   } else {
     p = new((void*) gvp) TH2D(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH2D));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_274_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH2D* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 7
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH2D(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]));
   } else {
     p = new((void*) gvp) TH2D(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH2D));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_274_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH2D* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 7
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH2D(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Double_t*) G__int(libp->para[6]));
   } else {
     p = new((void*) gvp) TH2D(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Double_t*) G__int(libp->para[6]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH2D));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_274_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH2D* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 6
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH2D(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5]));
   } else {
     p = new((void*) gvp) TH2D(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH2D));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_274_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH2D* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 6
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH2D(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Float_t*) G__int(libp->para[5]));
   } else {
     p = new((void*) gvp) TH2D(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Float_t*) G__int(libp->para[5]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH2D));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_274_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH2D* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH2D(*(TMatrixDBase*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TH2D(*(TMatrixDBase*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH2D));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_274_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH2D* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH2D(*(TH2D*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TH2D(*(TH2D*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH2D));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_274_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TH2D& obj = ((TH2D*) G__getstructoffset())->operator=(*(TH2D*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_274_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TH2D::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_274_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH2D::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_274_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TH2D::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_274_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TH2D::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_274_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TH2D*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_274_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH2D::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_274_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TH2D::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_274_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH2D::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_274_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TH2D::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TH2D G__TTH2D;
static int G__G__Hist_274_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TH2D*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TH2D*) (soff+(sizeof(TH2D)*i)))->~G__TTH2D();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TH2D*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TH2D*) (soff))->~G__TTH2D();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGraph2DErrors */
static int G__G__Hist_276_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraph2DErrors* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraph2DErrors[n];
     } else {
       p = new((void*) gvp) TGraph2DErrors[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraph2DErrors;
     } else {
       p = new((void*) gvp) TGraph2DErrors;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TGraph2DErrors));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_276_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraph2DErrors* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGraph2DErrors((Int_t) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGraph2DErrors((Int_t) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TGraph2DErrors));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_276_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraph2DErrors* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 8:
     //m: 8
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraph2DErrors(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5])
, (Double_t*) G__int(libp->para[6]), (Option_t*) G__int(libp->para[7]));
     } else {
       p = new((void*) gvp) TGraph2DErrors(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5])
, (Double_t*) G__int(libp->para[6]), (Option_t*) G__int(libp->para[7]));
     }
     break;
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraph2DErrors(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5])
, (Double_t*) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) TGraph2DErrors(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5])
, (Double_t*) G__int(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraph2DErrors(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGraph2DErrors(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraph2DErrors(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGraph2DErrors(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraph2DErrors(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGraph2DErrors(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TGraph2DErrors));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_276_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGraph2DErrors*) G__getstructoffset())->SetPointError((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_276_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGraph2DErrors::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_276_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGraph2DErrors::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_276_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGraph2DErrors::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_276_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGraph2DErrors::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_276_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGraph2DErrors*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_276_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGraph2DErrors::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_276_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGraph2DErrors::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_276_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGraph2DErrors::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_276_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGraph2DErrors::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGraph2DErrors G__TTGraph2DErrors;
static int G__G__Hist_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: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGraph2DErrors*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGraph2DErrors*) (soff+(sizeof(TGraph2DErrors)*i)))->~G__TTGraph2DErrors();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGraph2DErrors*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGraph2DErrors*) (soff))->~G__TTGraph2DErrors();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TH1F */
static int G__G__Hist_277_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH1F* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TH1F[n];
     } else {
       p = new((void*) gvp) TH1F[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TH1F;
     } else {
       p = new((void*) gvp) TH1F;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH1F));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_277_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH1F* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 5
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH1F(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
   } else {
     p = new((void*) gvp) TH1F(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH1F));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_277_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH1F* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH1F(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3]));
   } else {
     p = new((void*) gvp) TH1F(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH1F));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_277_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH1F* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH1F(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3]));
   } else {
     p = new((void*) gvp) TH1F(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH1F));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_277_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH1F* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH1F(*(TVectorF*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TH1F(*(TVectorF*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH1F));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_277_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH1F* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH1F(*(TH1F*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TH1F(*(TH1F*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH1F));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_277_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TH1F& obj = ((TH1F*) G__getstructoffset())->operator=(*(TH1F*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_277_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TH1F::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_277_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH1F::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_277_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TH1F::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_277_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TH1F::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_277_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TH1F*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_277_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH1F::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_277_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TH1F::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_277_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH1F::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_277_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TH1F::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TH1F G__TTH1F;
static int G__G__Hist_277_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TH1F*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TH1F*) (soff+(sizeof(TH1F)*i)))->~G__TTH1F();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TH1F*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TH1F*) (soff))->~G__TTH1F();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TSpline */
static int G__G__Hist_278_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TSpline*) G__getstructoffset())->GetKnot((Int_t) G__int(libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_278_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TSpline*) G__getstructoffset())->GetDelta());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_278_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TSpline*) G__getstructoffset())->GetHistogram());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_278_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TSpline*) G__getstructoffset())->GetNp());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_278_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TSpline*) G__getstructoffset())->GetNpx());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_278_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TSpline*) G__getstructoffset())->GetXmin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_278_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TSpline*) G__getstructoffset())->GetXmax());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_278_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TSpline*) G__getstructoffset())->Eval((Double_t) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_278_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSpline*) G__getstructoffset())->SetNpx((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_278_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TSpline::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_278_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSpline::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_278_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TSpline::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_278_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TSpline::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_278_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSpline*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_278_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSpline::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_278_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TSpline::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_278_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSpline::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_278_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TSpline::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TSpline G__TTSpline;
static int G__G__Hist_278_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TSpline*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TSpline*) (soff+(sizeof(TSpline)*i)))->~G__TTSpline();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TSpline*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TSpline*) (soff))->~G__TTSpline();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGraphBentErrors */
static int G__G__Hist_280_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraphBentErrors* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraphBentErrors[n];
     } else {
       p = new((void*) gvp) TGraphBentErrors[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraphBentErrors;
     } else {
       p = new((void*) gvp) TGraphBentErrors;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TGraphBentErrors));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_280_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraphBentErrors* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGraphBentErrors((Int_t) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGraphBentErrors((Int_t) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TGraphBentErrors));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_280_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraphBentErrors* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 11:
     //m: 11
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraphBentErrors(
(Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3])
, (Float_t*) G__int(libp->para[4]), (Float_t*) G__int(libp->para[5])
, (Float_t*) G__int(libp->para[6]), (Float_t*) G__int(libp->para[7])
, (Float_t*) G__int(libp->para[8]), (Float_t*) G__int(libp->para[9])
, (Float_t*) G__int(libp->para[10]));
     } else {
       p = new((void*) gvp) TGraphBentErrors(
(Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3])
, (Float_t*) G__int(libp->para[4]), (Float_t*) G__int(libp->para[5])
, (Float_t*) G__int(libp->para[6]), (Float_t*) G__int(libp->para[7])
, (Float_t*) G__int(libp->para[8]), (Float_t*) G__int(libp->para[9])
, (Float_t*) G__int(libp->para[10]));
     }
     break;
   case 10:
     //m: 10
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraphBentErrors(
(Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3])
, (Float_t*) G__int(libp->para[4]), (Float_t*) G__int(libp->para[5])
, (Float_t*) G__int(libp->para[6]), (Float_t*) G__int(libp->para[7])
, (Float_t*) G__int(libp->para[8]), (Float_t*) G__int(libp->para[9]));
     } else {
       p = new((void*) gvp) TGraphBentErrors(
(Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3])
, (Float_t*) G__int(libp->para[4]), (Float_t*) G__int(libp->para[5])
, (Float_t*) G__int(libp->para[6]), (Float_t*) G__int(libp->para[7])
, (Float_t*) G__int(libp->para[8]), (Float_t*) G__int(libp->para[9]));
     }
     break;
   case 9:
     //m: 9
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraphBentErrors(
(Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3])
, (Float_t*) G__int(libp->para[4]), (Float_t*) G__int(libp->para[5])
, (Float_t*) G__int(libp->para[6]), (Float_t*) G__int(libp->para[7])
, (Float_t*) G__int(libp->para[8]));
     } else {
       p = new((void*) gvp) TGraphBentErrors(
(Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3])
, (Float_t*) G__int(libp->para[4]), (Float_t*) G__int(libp->para[5])
, (Float_t*) G__int(libp->para[6]), (Float_t*) G__int(libp->para[7])
, (Float_t*) G__int(libp->para[8]));
     }
     break;
   case 8:
     //m: 8
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraphBentErrors(
(Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3])
, (Float_t*) G__int(libp->para[4]), (Float_t*) G__int(libp->para[5])
, (Float_t*) G__int(libp->para[6]), (Float_t*) G__int(libp->para[7]));
     } else {
       p = new((void*) gvp) TGraphBentErrors(
(Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3])
, (Float_t*) G__int(libp->para[4]), (Float_t*) G__int(libp->para[5])
, (Float_t*) G__int(libp->para[6]), (Float_t*) G__int(libp->para[7]));
     }
     break;
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraphBentErrors(
(Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3])
, (Float_t*) G__int(libp->para[4]), (Float_t*) G__int(libp->para[5])
, (Float_t*) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) TGraphBentErrors(
(Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3])
, (Float_t*) G__int(libp->para[4]), (Float_t*) G__int(libp->para[5])
, (Float_t*) G__int(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraphBentErrors(
(Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3])
, (Float_t*) G__int(libp->para[4]), (Float_t*) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGraphBentErrors(
(Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3])
, (Float_t*) G__int(libp->para[4]), (Float_t*) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraphBentErrors(
(Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3])
, (Float_t*) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGraphBentErrors(
(Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3])
, (Float_t*) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraphBentErrors(
(Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGraphBentErrors(
(Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraphBentErrors(
(Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGraphBentErrors(
(Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TGraphBentErrors));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_280_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraphBentErrors* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 11:
     //m: 11
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraphBentErrors(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5])
, (Double_t*) G__int(libp->para[6]), (Double_t*) G__int(libp->para[7])
, (Double_t*) G__int(libp->para[8]), (Double_t*) G__int(libp->para[9])
, (Double_t*) G__int(libp->para[10]));
     } else {
       p = new((void*) gvp) TGraphBentErrors(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5])
, (Double_t*) G__int(libp->para[6]), (Double_t*) G__int(libp->para[7])
, (Double_t*) G__int(libp->para[8]), (Double_t*) G__int(libp->para[9])
, (Double_t*) G__int(libp->para[10]));
     }
     break;
   case 10:
     //m: 10
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraphBentErrors(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5])
, (Double_t*) G__int(libp->para[6]), (Double_t*) G__int(libp->para[7])
, (Double_t*) G__int(libp->para[8]), (Double_t*) G__int(libp->para[9]));
     } else {
       p = new((void*) gvp) TGraphBentErrors(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5])
, (Double_t*) G__int(libp->para[6]), (Double_t*) G__int(libp->para[7])
, (Double_t*) G__int(libp->para[8]), (Double_t*) G__int(libp->para[9]));
     }
     break;
   case 9:
     //m: 9
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraphBentErrors(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5])
, (Double_t*) G__int(libp->para[6]), (Double_t*) G__int(libp->para[7])
, (Double_t*) G__int(libp->para[8]));
     } else {
       p = new((void*) gvp) TGraphBentErrors(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5])
, (Double_t*) G__int(libp->para[6]), (Double_t*) G__int(libp->para[7])
, (Double_t*) G__int(libp->para[8]));
     }
     break;
   case 8:
     //m: 8
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraphBentErrors(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5])
, (Double_t*) G__int(libp->para[6]), (Double_t*) G__int(libp->para[7]));
     } else {
       p = new((void*) gvp) TGraphBentErrors(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5])
, (Double_t*) G__int(libp->para[6]), (Double_t*) G__int(libp->para[7]));
     }
     break;
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraphBentErrors(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5])
, (Double_t*) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) TGraphBentErrors(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5])
, (Double_t*) G__int(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraphBentErrors(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TGraphBentErrors(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraphBentErrors(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGraphBentErrors(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraphBentErrors(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGraphBentErrors(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraphBentErrors(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGraphBentErrors(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TGraphBentErrors));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_280_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraphBentErrors* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGraphBentErrors(*(TGraphBentErrors*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TGraphBentErrors(*(TGraphBentErrors*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TGraphBentErrors));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_280_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 8:
      ((TGraphBentErrors*) G__getstructoffset())->SetPointError(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7]));
      G__setnull(result7);
      break;
   case 7:
      ((TGraphBentErrors*) G__getstructoffset())->SetPointError(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]));
      G__setnull(result7);
      break;
   case 6:
      ((TGraphBentErrors*) G__getstructoffset())->SetPointError((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
      G__setnull(result7);
      break;
   case 5:
      ((TGraphBentErrors*) G__getstructoffset())->SetPointError((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TGraphBentErrors*) G__getstructoffset())->SetPointError((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_280_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 9:
      ((TGraphBentErrors*) G__getstructoffset())->SetPointError(
(Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]));
      G__setnull(result7);
      break;
   case 8:
      ((TGraphBentErrors*) G__getstructoffset())->SetPointError(
(Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7]));
      G__setnull(result7);
      break;
   case 7:
      ((TGraphBentErrors*) G__getstructoffset())->SetPointError(
(Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]));
      G__setnull(result7);
      break;
   case 6:
      ((TGraphBentErrors*) G__getstructoffset())->SetPointError((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
      G__setnull(result7);
      break;
   case 5:
      ((TGraphBentErrors*) G__getstructoffset())->SetPointError((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_280_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGraphBentErrors::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_280_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGraphBentErrors::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_280_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGraphBentErrors::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_280_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGraphBentErrors::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_280_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGraphBentErrors*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_280_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGraphBentErrors::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_280_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGraphBentErrors::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_280_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGraphBentErrors::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_280_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGraphBentErrors::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGraphBentErrors G__TTGraphBentErrors;
static int G__G__Hist_280_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGraphBentErrors*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGraphBentErrors*) (soff+(sizeof(TGraphBentErrors)*i)))->~G__TTGraphBentErrors();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGraphBentErrors*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGraphBentErrors*) (soff))->~G__TTGraphBentErrors();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Hist_280_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraphBentErrors* dest = (TGraphBentErrors*) G__getstructoffset();
   *dest = *(TGraphBentErrors*) libp->para[0].ref;
   const TGraphBentErrors& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGraphDelaunay */
static int G__G__Hist_281_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraphDelaunay* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraphDelaunay[n];
     } else {
       p = new((void*) gvp) TGraphDelaunay[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraphDelaunay;
     } else {
       p = new((void*) gvp) TGraphDelaunay;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TGraphDelaunay));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_281_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraphDelaunay* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGraphDelaunay((TGraph2D*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGraphDelaunay((TGraph2D*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TGraphDelaunay));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_281_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TGraphDelaunay*) G__getstructoffset())->ComputeZ((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_281_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGraphDelaunay*) G__getstructoffset())->FindAllTriangles();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_281_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGraphDelaunay*) G__getstructoffset())->GetGraph2D());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_281_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGraphDelaunay*) G__getstructoffset())->GetMarginBinsContent());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_281_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGraphDelaunay*) G__getstructoffset())->GetNdt());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_281_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 73, (long) ((const TGraphDelaunay*) G__getstructoffset())->GetPTried());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_281_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 73, (long) ((const TGraphDelaunay*) G__getstructoffset())->GetNTried());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_281_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 73, (long) ((const TGraphDelaunay*) G__getstructoffset())->GetMTried());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_281_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TGraphDelaunay*) G__getstructoffset())->GetXN());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_281_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TGraphDelaunay*) G__getstructoffset())->GetYN());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_281_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGraphDelaunay*) G__getstructoffset())->GetXNmin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_281_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGraphDelaunay*) G__getstructoffset())->GetXNmax());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_281_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGraphDelaunay*) G__getstructoffset())->GetYNmin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_281_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGraphDelaunay*) G__getstructoffset())->GetYNmax());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_281_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TGraphDelaunay*) G__getstructoffset())->Interpolate((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_281_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGraphDelaunay*) G__getstructoffset())->SetMaxIter((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGraphDelaunay*) G__getstructoffset())->SetMaxIter();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_281_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGraphDelaunay*) G__getstructoffset())->SetMarginBinsContent((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGraphDelaunay*) G__getstructoffset())->SetMarginBinsContent();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_281_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGraphDelaunay::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_281_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGraphDelaunay::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_281_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGraphDelaunay::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_281_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGraphDelaunay::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_281_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGraphDelaunay*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_281_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGraphDelaunay::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_281_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGraphDelaunay::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_281_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGraphDelaunay::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_281_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGraphDelaunay::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGraphDelaunay G__TTGraphDelaunay;
static int G__G__Hist_281_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGraphDelaunay*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGraphDelaunay*) (soff+(sizeof(TGraphDelaunay)*i)))->~G__TTGraphDelaunay();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGraphDelaunay*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGraphDelaunay*) (soff))->~G__TTGraphDelaunay();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGraphSmooth */
static int G__G__Hist_282_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraphSmooth* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraphSmooth[n];
     } else {
       p = new((void*) gvp) TGraphSmooth[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraphSmooth;
     } else {
       p = new((void*) gvp) TGraphSmooth;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TGraphSmooth));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_282_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraphSmooth* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGraphSmooth((const char*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGraphSmooth((const char*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TGraphSmooth));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_282_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 9:
      G__letint(result7, 85, (long) ((TGraphSmooth*) G__getstructoffset())->Approx(
(TGraph*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Option_t*) G__int(libp->para[8])));
      break;
   case 8:
      G__letint(result7, 85, (long) ((TGraphSmooth*) G__getstructoffset())->Approx(
(TGraph*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Double_t) G__double(libp->para[7])));
      break;
   case 7:
      G__letint(result7, 85, (long) ((TGraphSmooth*) G__getstructoffset())->Approx(
(TGraph*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Int_t) G__int(libp->para[6])));
      break;
   case 6:
      G__letint(result7, 85, (long) ((TGraphSmooth*) G__getstructoffset())->Approx((TGraph*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])));
      break;
   case 5:
      G__letint(result7, 85, (long) ((TGraphSmooth*) G__getstructoffset())->Approx((TGraph*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Double_t) G__double(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 85, (long) ((TGraphSmooth*) G__getstructoffset())->Approx((TGraph*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 85, (long) ((TGraphSmooth*) G__getstructoffset())->Approx((TGraph*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((TGraphSmooth*) G__getstructoffset())->Approx((TGraph*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TGraphSmooth*) G__getstructoffset())->Approx((TGraph*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_282_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letint(result7, 85, (long) ((TGraphSmooth*) G__getstructoffset())->SmoothKern((TGraph*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 85, (long) ((TGraphSmooth*) G__getstructoffset())->SmoothKern((TGraph*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Int_t) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 85, (long) ((TGraphSmooth*) G__getstructoffset())->SmoothKern((TGraph*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((TGraphSmooth*) G__getstructoffset())->SmoothKern((TGraph*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TGraphSmooth*) G__getstructoffset())->SmoothKern((TGraph*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_282_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letint(result7, 85, (long) ((TGraphSmooth*) G__getstructoffset())->SmoothLowess((TGraph*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Double_t) G__double(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 85, (long) ((TGraphSmooth*) G__getstructoffset())->SmoothLowess((TGraph*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Int_t) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 85, (long) ((TGraphSmooth*) G__getstructoffset())->SmoothLowess((TGraph*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((TGraphSmooth*) G__getstructoffset())->SmoothLowess((TGraph*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TGraphSmooth*) G__getstructoffset())->SmoothLowess((TGraph*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_282_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 6:
      G__letint(result7, 85, (long) ((TGraphSmooth*) G__getstructoffset())->SmoothSuper((TGraph*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Bool_t) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5])));
      break;
   case 5:
      G__letint(result7, 85, (long) ((TGraphSmooth*) G__getstructoffset())->SmoothSuper((TGraph*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Bool_t) G__int(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 85, (long) ((TGraphSmooth*) G__getstructoffset())->SmoothSuper((TGraph*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 85, (long) ((TGraphSmooth*) G__getstructoffset())->SmoothSuper((TGraph*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((TGraphSmooth*) G__getstructoffset())->SmoothSuper((TGraph*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TGraphSmooth*) G__getstructoffset())->SmoothSuper((TGraph*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_282_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGraphSmooth*) G__getstructoffset())->Approxin((TGraph*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2]), *(Double_t*) G__Doubleref(&libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_282_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGraphSmooth*) G__getstructoffset())->Smoothin((TGraph*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_282_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) TGraphSmooth::Approx1(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_282_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGraphSmooth*) G__getstructoffset())->Lowess(
(Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_282_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGraphSmooth::Lowest(
(Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), *(Double_t*) G__Doubleref(&libp->para[3])
, *(Double_t*) G__Doubleref(&libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Double_t*) G__int(libp->para[7])
, (Bool_t) G__int(libp->para[8]), (Double_t*) G__int(libp->para[9])
, *(Bool_t*) G__Boolref(&libp->para[10]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_282_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGraphSmooth::Rcmp((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_282_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGraphSmooth::Psort((Double_t*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_282_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      TGraphSmooth::Rank((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Int_t*) G__int(libp->para[2]), (Int_t*) G__int(libp->para[3])
, (Bool_t) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      TGraphSmooth::Rank((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Int_t*) G__int(libp->para[2]), (Int_t*) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_282_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGraphSmooth::BDRksmooth(
(Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Double_t) G__double(libp->para[7]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_282_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGraphSmooth::BDRsupsmu(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t*) G__int(libp->para[7])
, (Double_t*) G__int(libp->para[8]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_282_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGraphSmooth::BDRsmooth(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t*) G__int(libp->para[7])
, (Double_t*) G__int(libp->para[8]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_282_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGraphSmooth::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_282_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGraphSmooth::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_282_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGraphSmooth::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_282_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGraphSmooth::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_282_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGraphSmooth*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_282_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGraphSmooth::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_282_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGraphSmooth::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_282_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGraphSmooth::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_282_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGraphSmooth::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGraphSmooth G__TTGraphSmooth;
static int G__G__Hist_282_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGraphSmooth*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGraphSmooth*) (soff+(sizeof(TGraphSmooth)*i)))->~G__TTGraphSmooth();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGraphSmooth*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGraphSmooth*) (soff))->~G__TTGraphSmooth();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGraphTime */
static int G__G__Hist_283_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraphTime* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraphTime[n];
     } else {
       p = new((void*) gvp) TGraphTime[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGraphTime;
     } else {
       p = new((void*) gvp) TGraphTime;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TGraphTime));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_283_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraphTime* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 5
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGraphTime(
(Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
   } else {
     p = new((void*) gvp) TGraphTime(
(Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TGraphTime));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_283_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraphTime* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGraphTime(*(TGraphTime*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TGraphTime(*(TGraphTime*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TGraphTime));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_283_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 105, (long) ((TGraphTime*) G__getstructoffset())->Add((TObject*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 105, (long) ((TGraphTime*) G__getstructoffset())->Add((TObject*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_283_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGraphTime*) G__getstructoffset())->GetSteps());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_283_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((const TGraphTime*) G__getstructoffset())->SaveAnimatedGif((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((const TGraphTime*) G__getstructoffset())->SaveAnimatedGif();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_283_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGraphTime*) G__getstructoffset())->SetSleepTime((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGraphTime*) G__getstructoffset())->SetSleepTime();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_283_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGraphTime::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_283_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGraphTime::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_283_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGraphTime::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_283_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGraphTime::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_283_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGraphTime*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_283_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGraphTime::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_283_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGraphTime::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_283_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGraphTime::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_283_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGraphTime::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGraphTime G__TTGraphTime;
static int G__G__Hist_283_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGraphTime*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGraphTime*) (soff+(sizeof(TGraphTime)*i)))->~G__TTGraphTime();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGraphTime*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGraphTime*) (soff))->~G__TTGraphTime();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Hist_283_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGraphTime* dest = (TGraphTime*) G__getstructoffset();
   *dest = *(TGraphTime*) libp->para[0].ref;
   const TGraphTime& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TH1D */
static int G__G__Hist_288_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH1D* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TH1D[n];
     } else {
       p = new((void*) gvp) TH1D[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TH1D;
     } else {
       p = new((void*) gvp) TH1D;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH1D));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_288_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH1D* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 5
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH1D(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
   } else {
     p = new((void*) gvp) TH1D(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH1D));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_288_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH1D* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH1D(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3]));
   } else {
     p = new((void*) gvp) TH1D(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH1D));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_288_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH1D* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH1D(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3]));
   } else {
     p = new((void*) gvp) TH1D(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH1D));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_288_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH1D* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH1D(*(TVectorD*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TH1D(*(TVectorD*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH1D));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_288_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH1D* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH1D(*(TH1D*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TH1D(*(TH1D*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH1D));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_288_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TH1D& obj = ((TH1D*) G__getstructoffset())->operator=(*(TH1D*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_288_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TH1D::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_288_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH1D::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_288_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TH1D::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_288_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TH1D::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_288_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TH1D*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_288_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH1D::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_288_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TH1D::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_288_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH1D::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_288_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TH1D::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TH1D G__TTH1D;
static int G__G__Hist_288_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TH1D*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TH1D*) (soff+(sizeof(TH1D)*i)))->~G__TTH1D();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TH1D*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TH1D*) (soff))->~G__TTH1D();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TH1C */
static int G__G__Hist_291_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH1C* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TH1C[n];
     } else {
       p = new((void*) gvp) TH1C[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TH1C;
     } else {
       p = new((void*) gvp) TH1C;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH1C));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_291_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH1C* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 5
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH1C(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
   } else {
     p = new((void*) gvp) TH1C(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH1C));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_291_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH1C* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH1C(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3]));
   } else {
     p = new((void*) gvp) TH1C(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH1C));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_291_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH1C* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH1C(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3]));
   } else {
     p = new((void*) gvp) TH1C(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH1C));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_291_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH1C* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH1C(*(TH1C*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TH1C(*(TH1C*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH1C));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_291_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TH1C& obj = ((TH1C*) G__getstructoffset())->operator=(*(TH1C*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_291_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TH1C::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_291_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH1C::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_291_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TH1C::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_291_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TH1C::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_291_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TH1C*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_291_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH1C::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_291_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TH1C::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_291_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH1C::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_291_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TH1C::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TH1C G__TTH1C;
static int G__G__Hist_291_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TH1C*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TH1C*) (soff+(sizeof(TH1C)*i)))->~G__TTH1C();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TH1C*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TH1C*) (soff))->~G__TTH1C();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TH1S */
static int G__G__Hist_292_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH1S* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TH1S[n];
     } else {
       p = new((void*) gvp) TH1S[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TH1S;
     } else {
       p = new((void*) gvp) TH1S;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH1S));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_292_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH1S* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 5
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH1S(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
   } else {
     p = new((void*) gvp) TH1S(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH1S));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_292_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH1S* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH1S(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3]));
   } else {
     p = new((void*) gvp) TH1S(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH1S));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_292_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH1S* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH1S(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3]));
   } else {
     p = new((void*) gvp) TH1S(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH1S));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_292_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH1S* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH1S(*(TH1S*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TH1S(*(TH1S*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH1S));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_292_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TH1S& obj = ((TH1S*) G__getstructoffset())->operator=(*(TH1S*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_292_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TH1S::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_292_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH1S::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_292_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TH1S::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_292_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TH1S::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_292_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TH1S*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_292_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH1S::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_292_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TH1S::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_292_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH1S::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_292_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TH1S::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TH1S G__TTH1S;
static int G__G__Hist_292_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TH1S*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TH1S*) (soff+(sizeof(TH1S)*i)))->~G__TTH1S();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TH1S*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TH1S*) (soff))->~G__TTH1S();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TH1I */
static int G__G__Hist_293_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH1I* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TH1I[n];
     } else {
       p = new((void*) gvp) TH1I[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TH1I;
     } else {
       p = new((void*) gvp) TH1I;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH1I));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_293_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH1I* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 5
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH1I(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
   } else {
     p = new((void*) gvp) TH1I(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH1I));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_293_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH1I* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH1I(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3]));
   } else {
     p = new((void*) gvp) TH1I(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH1I));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_293_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH1I* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH1I(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3]));
   } else {
     p = new((void*) gvp) TH1I(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH1I));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_293_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH1I* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH1I(*(TH1I*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TH1I(*(TH1I*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH1I));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_293_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TH1I& obj = ((TH1I*) G__getstructoffset())->operator=(*(TH1I*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_293_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TH1I::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_293_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH1I::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_293_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TH1I::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_293_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TH1I::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_293_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TH1I*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_293_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH1I::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_293_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TH1I::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_293_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH1I::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_293_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TH1I::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TH1I G__TTH1I;
static int G__G__Hist_293_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TH1I*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TH1I*) (soff+(sizeof(TH1I)*i)))->~G__TTH1I();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TH1I*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TH1I*) (soff))->~G__TTH1I();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TH1K */
static int G__G__Hist_294_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH1K* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TH1K[n];
     } else {
       p = new((void*) gvp) TH1K[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TH1K;
     } else {
       p = new((void*) gvp) TH1K;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH1K));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_294_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH1K* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TH1K(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TH1K(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TH1K(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
     } else {
       p = new((void*) gvp) TH1K(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH1K));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_294_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TH1K*) G__getstructoffset())->SetKOrd((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_294_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TH1K::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_294_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH1K::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_294_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TH1K::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_294_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TH1K::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_294_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TH1K*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_294_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH1K::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_294_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TH1K::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_294_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH1K::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_294_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TH1K::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Hist_294_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TH1K* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TH1K(*(TH1K*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH1K));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TH1K G__TTH1K;
static int G__G__Hist_294_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TH1K*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TH1K*) (soff+(sizeof(TH1K)*i)))->~G__TTH1K();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TH1K*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TH1K*) (soff))->~G__TTH1K();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TProfile */
static int G__G__Hist_295_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TProfile* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TProfile[n];
     } else {
       p = new((void*) gvp) TProfile[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TProfile;
     } else {
       p = new((void*) gvp) TProfile;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TProfile));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_295_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TProfile* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TProfile(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Option_t*) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TProfile(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Option_t*) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TProfile(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
     } else {
       p = new((void*) gvp) TProfile(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TProfile));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_295_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TProfile* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 8:
     //m: 8
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TProfile(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Option_t*) G__int(libp->para[7]));
     } else {
       p = new((void*) gvp) TProfile(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Option_t*) G__int(libp->para[7]));
     }
     break;
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TProfile(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]));
     } else {
       p = new((void*) gvp) TProfile(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TProfile));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_295_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TProfile* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TProfile(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3])
, (Option_t*) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TProfile(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3])
, (Option_t*) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TProfile(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TProfile(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TProfile));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_295_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TProfile* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TProfile(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Option_t*) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TProfile(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Option_t*) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TProfile(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TProfile(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TProfile));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_295_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TProfile* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TProfile(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Option_t*) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) TProfile(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Option_t*) G__int(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TProfile(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
     } else {
       p = new((void*) gvp) TProfile(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TProfile));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_295_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TProfile* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TProfile(*(TProfile*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TProfile(*(TProfile*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TProfile));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_295_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      TProfile::Approximate((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      TProfile::Approximate();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_295_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TProfile*) G__getstructoffset())->BuildOptions((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Option_t*) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_295_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TProfile*) G__getstructoffset())->Fill((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_295_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TProfile*) G__getstructoffset())->Fill((const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_295_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      ((TProfile*) G__getstructoffset())->FillN((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TProfile*) G__getstructoffset())->FillN((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_295_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TProfile*) G__getstructoffset())->GetBinEntries((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_295_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TProfile*) G__getstructoffset())->GetBinEffectiveEntries((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_295_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TProfile*) G__getstructoffset())->GetBinSumw2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_295_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TProfile*) G__getstructoffset())->GetBinSumw2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_295_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TProfile*) G__getstructoffset())->GetErrorOption());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_295_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TProfile*) G__getstructoffset())->GetYmin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_295_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TProfile*) G__getstructoffset())->GetYmax());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_295_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 85, (long) ((const TProfile*) G__getstructoffset())->ProjectionX((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((const TProfile*) G__getstructoffset())->ProjectionX((const char*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((const TProfile*) G__getstructoffset())->ProjectionX());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_295_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TProfile*) G__getstructoffset())->SetBinEntries((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_295_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TProfile*) G__getstructoffset())->SetErrorOption((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TProfile*) G__getstructoffset())->SetErrorOption();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_295_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TProfile::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_295_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TProfile::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_295_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TProfile::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_295_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TProfile::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_295_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TProfile*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_295_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TProfile::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_295_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TProfile::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_295_0_83(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TProfile::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_295_0_84(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TProfile::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TProfile G__TTProfile;
static int G__G__Hist_295_0_85(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TProfile*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TProfile*) (soff+(sizeof(TProfile)*i)))->~G__TTProfile();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TProfile*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TProfile*) (soff))->~G__TTProfile();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TH2C */
static int G__G__Hist_296_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH2C* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TH2C[n];
     } else {
       p = new((void*) gvp) TH2C[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TH2C;
     } else {
       p = new((void*) gvp) TH2C;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH2C));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_296_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH2C* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 8
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH2C(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7]));
   } else {
     p = new((void*) gvp) TH2C(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH2C));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_296_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH2C* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 7
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH2C(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]));
   } else {
     p = new((void*) gvp) TH2C(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH2C));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_296_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH2C* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 7
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH2C(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Double_t*) G__int(libp->para[6]));
   } else {
     p = new((void*) gvp) TH2C(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Double_t*) G__int(libp->para[6]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH2C));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_296_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH2C* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 6
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH2C(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5]));
   } else {
     p = new((void*) gvp) TH2C(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH2C));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_296_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH2C* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 6
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH2C(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Float_t*) G__int(libp->para[5]));
   } else {
     p = new((void*) gvp) TH2C(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Float_t*) G__int(libp->para[5]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH2C));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_296_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH2C* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH2C(*(TH2C*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TH2C(*(TH2C*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH2C));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_296_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TH2C& obj = ((TH2C*) G__getstructoffset())->operator=(*(TH2C*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_296_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TH2C::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_296_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH2C::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_296_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TH2C::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_296_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TH2C::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_296_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TH2C*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_296_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH2C::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_296_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TH2C::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_296_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH2C::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_296_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TH2C::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TH2C G__TTH2C;
static int G__G__Hist_296_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TH2C*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TH2C*) (soff+(sizeof(TH2C)*i)))->~G__TTH2C();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TH2C*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TH2C*) (soff))->~G__TTH2C();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TH2S */
static int G__G__Hist_297_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH2S* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TH2S[n];
     } else {
       p = new((void*) gvp) TH2S[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TH2S;
     } else {
       p = new((void*) gvp) TH2S;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH2S));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_297_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH2S* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 8
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH2S(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7]));
   } else {
     p = new((void*) gvp) TH2S(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH2S));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_297_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH2S* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 7
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH2S(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]));
   } else {
     p = new((void*) gvp) TH2S(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH2S));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_297_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH2S* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 7
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH2S(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Double_t*) G__int(libp->para[6]));
   } else {
     p = new((void*) gvp) TH2S(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Double_t*) G__int(libp->para[6]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH2S));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_297_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH2S* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 6
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH2S(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5]));
   } else {
     p = new((void*) gvp) TH2S(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH2S));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_297_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH2S* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 6
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH2S(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Float_t*) G__int(libp->para[5]));
   } else {
     p = new((void*) gvp) TH2S(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Float_t*) G__int(libp->para[5]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH2S));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_297_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH2S* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH2S(*(TH2S*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TH2S(*(TH2S*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH2S));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_297_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TH2S& obj = ((TH2S*) G__getstructoffset())->operator=(*(TH2S*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_297_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TH2S::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_297_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH2S::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_297_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TH2S::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_297_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TH2S::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_297_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TH2S*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_297_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH2S::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_297_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TH2S::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_297_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH2S::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_297_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TH2S::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TH2S G__TTH2S;
static int G__G__Hist_297_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TH2S*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TH2S*) (soff+(sizeof(TH2S)*i)))->~G__TTH2S();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TH2S*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TH2S*) (soff))->~G__TTH2S();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TH2I */
static int G__G__Hist_298_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH2I* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TH2I[n];
     } else {
       p = new((void*) gvp) TH2I[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TH2I;
     } else {
       p = new((void*) gvp) TH2I;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH2I));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_298_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH2I* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 8
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH2I(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7]));
   } else {
     p = new((void*) gvp) TH2I(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH2I));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_298_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH2I* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 7
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH2I(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]));
   } else {
     p = new((void*) gvp) TH2I(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH2I));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_298_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH2I* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 7
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH2I(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Double_t*) G__int(libp->para[6]));
   } else {
     p = new((void*) gvp) TH2I(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Double_t*) G__int(libp->para[6]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH2I));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_298_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH2I* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 6
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH2I(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5]));
   } else {
     p = new((void*) gvp) TH2I(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH2I));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_298_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH2I* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 6
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH2I(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Float_t*) G__int(libp->para[5]));
   } else {
     p = new((void*) gvp) TH2I(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Float_t*) G__int(libp->para[5]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH2I));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_298_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH2I* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH2I(*(TH2I*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TH2I(*(TH2I*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH2I));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_298_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TH2I& obj = ((TH2I*) G__getstructoffset())->operator=(*(TH2I*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_298_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TH2I::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_298_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH2I::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_298_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TH2I::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_298_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TH2I::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_298_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TH2I*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_298_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH2I::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_298_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TH2I::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_298_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH2I::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_298_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TH2I::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TH2I G__TTH2I;
static int G__G__Hist_298_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TH2I*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TH2I*) (soff+(sizeof(TH2I)*i)))->~G__TTH2I();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TH2I*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TH2I*) (soff))->~G__TTH2I();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TH2F */
static int G__G__Hist_299_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH2F* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TH2F[n];
     } else {
       p = new((void*) gvp) TH2F[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TH2F;
     } else {
       p = new((void*) gvp) TH2F;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH2F));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_299_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH2F* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 8
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH2F(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7]));
   } else {
     p = new((void*) gvp) TH2F(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH2F));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_299_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH2F* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 7
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH2F(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]));
   } else {
     p = new((void*) gvp) TH2F(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH2F));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_299_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH2F* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 7
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH2F(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Double_t*) G__int(libp->para[6]));
   } else {
     p = new((void*) gvp) TH2F(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Double_t*) G__int(libp->para[6]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH2F));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_299_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH2F* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 6
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH2F(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5]));
   } else {
     p = new((void*) gvp) TH2F(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH2F));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_299_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH2F* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 6
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH2F(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Float_t*) G__int(libp->para[5]));
   } else {
     p = new((void*) gvp) TH2F(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Float_t*) G__int(libp->para[5]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH2F));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_299_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH2F* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH2F(*(TMatrixFBase*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TH2F(*(TMatrixFBase*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH2F));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_299_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH2F* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH2F(*(TH2F*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TH2F(*(TH2F*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH2F));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_299_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TH2F& obj = ((TH2F*) G__getstructoffset())->operator=(*(TH2F*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_299_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TH2F::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_299_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH2F::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_299_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TH2F::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_299_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TH2F::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_299_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TH2F*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_299_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH2F::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_299_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TH2F::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_299_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH2F::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_299_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TH2F::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TH2F G__TTH2F;
static int G__G__Hist_299_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TH2F*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TH2F*) (soff+(sizeof(TH2F)*i)))->~G__TTH2F();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TH2F*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TH2F*) (soff))->~G__TTH2F();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TH2PolyBin */
static int G__G__Hist_303_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH2PolyBin* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TH2PolyBin[n];
     } else {
       p = new((void*) gvp) TH2PolyBin[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TH2PolyBin;
     } else {
       p = new((void*) gvp) TH2PolyBin;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH2PolyBin));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_303_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH2PolyBin* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH2PolyBin((TObject*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TH2PolyBin((TObject*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH2PolyBin));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_303_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TH2PolyBin*) G__getstructoffset())->ClearContent();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_303_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TH2PolyBin*) G__getstructoffset())->Fill((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_303_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TH2PolyBin*) G__getstructoffset())->GetArea());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_303_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TH2PolyBin*) G__getstructoffset())->GetContent());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_303_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TH2PolyBin*) G__getstructoffset())->GetChanged());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_303_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TH2PolyBin*) G__getstructoffset())->GetBinNumber());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_303_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TH2PolyBin*) G__getstructoffset())->GetPolygon());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_303_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TH2PolyBin*) G__getstructoffset())->GetXMax());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_303_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TH2PolyBin*) G__getstructoffset())->GetXMin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_303_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TH2PolyBin*) G__getstructoffset())->GetYMax());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_303_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TH2PolyBin*) G__getstructoffset())->GetYMin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_303_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TH2PolyBin*) G__getstructoffset())->IsInside((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_303_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TH2PolyBin*) G__getstructoffset())->SetChanged((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_303_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TH2PolyBin*) G__getstructoffset())->SetContent((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_303_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TH2PolyBin::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_303_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH2PolyBin::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_303_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TH2PolyBin::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_303_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TH2PolyBin::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_303_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TH2PolyBin*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_303_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH2PolyBin::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_303_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TH2PolyBin::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_303_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH2PolyBin::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_303_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TH2PolyBin::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Hist_303_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TH2PolyBin* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TH2PolyBin(*(TH2PolyBin*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH2PolyBin));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TH2PolyBin G__TTH2PolyBin;
static int G__G__Hist_303_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: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TH2PolyBin*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TH2PolyBin*) (soff+(sizeof(TH2PolyBin)*i)))->~G__TTH2PolyBin();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TH2PolyBin*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TH2PolyBin*) (soff))->~G__TTH2PolyBin();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Hist_303_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH2PolyBin* dest = (TH2PolyBin*) G__getstructoffset();
   *dest = *(TH2PolyBin*) libp->para[0].ref;
   const TH2PolyBin& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TH2Poly */
static int G__G__Hist_305_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH2Poly* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TH2Poly[n];
     } else {
       p = new((void*) gvp) TH2Poly[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TH2Poly;
     } else {
       p = new((void*) gvp) TH2Poly;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH2Poly));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_305_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH2Poly* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 6
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH2Poly(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
   } else {
     p = new((void*) gvp) TH2Poly(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH2Poly));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_305_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH2Poly* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 8
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH2Poly(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7]));
   } else {
     p = new((void*) gvp) TH2Poly(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH2Poly));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_305_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TH2Poly*) G__getstructoffset())->AddBin((TObject*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_305_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TH2Poly*) G__getstructoffset())->AddBin((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_305_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TH2Poly*) G__getstructoffset())->AddBin((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_305_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TH2Poly*) G__getstructoffset())->ClearBinContents();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_305_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TH2Poly*) G__getstructoffset())->ChangePartition((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_305_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TH2Poly*) G__getstructoffset())->GetBins());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_305_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TH2Poly*) G__getstructoffset())->GetBinContentChanged());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_305_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TH2Poly*) G__getstructoffset())->GetBinName((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_305_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TH2Poly*) G__getstructoffset())->GetBinTitle((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_305_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TH2Poly*) G__getstructoffset())->GetFloat());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_305_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TH2Poly*) G__getstructoffset())->GetMaximum());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_305_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TH2Poly*) G__getstructoffset())->GetMinimum());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_305_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TH2Poly*) G__getstructoffset())->GetNewBinAdded());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_305_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TH2Poly*) G__getstructoffset())->GetNumberOfBins());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_305_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TH2Poly*) G__getstructoffset())->Honeycomb((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_305_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TH2Poly*) G__getstructoffset())->SetBinContentChanged((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_305_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TH2Poly*) G__getstructoffset())->SetFloat((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TH2Poly*) G__getstructoffset())->SetFloat();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_305_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TH2Poly*) G__getstructoffset())->SetNewBinAdded((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_305_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TH2Poly::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_305_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH2Poly::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_305_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TH2Poly::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_305_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TH2Poly::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_305_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TH2Poly*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_305_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH2Poly::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_305_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TH2Poly::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_305_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH2Poly::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_305_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TH2Poly::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Hist_305_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TH2Poly* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TH2Poly(*(TH2Poly*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH2Poly));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TH2Poly G__TTH2Poly;
static int G__G__Hist_305_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TH2Poly*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TH2Poly*) (soff+(sizeof(TH2Poly)*i)))->~G__TTH2Poly();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TH2Poly*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TH2Poly*) (soff))->~G__TTH2Poly();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TProfile2D */
static int G__G__Hist_307_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TProfile2D* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TProfile2D[n];
     } else {
       p = new((void*) gvp) TProfile2D[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TProfile2D;
     } else {
       p = new((void*) gvp) TProfile2D;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TProfile2D));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_307_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TProfile2D* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 11:
     //m: 11
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TProfile2D(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]), (Double_t) G__double(libp->para[9])
, (Option_t*) G__int(libp->para[10]));
     } else {
       p = new((void*) gvp) TProfile2D(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]), (Double_t) G__double(libp->para[9])
, (Option_t*) G__int(libp->para[10]));
     }
     break;
   case 10:
     //m: 10
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TProfile2D(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]), (Double_t) G__double(libp->para[9]));
     } else {
       p = new((void*) gvp) TProfile2D(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]), (Double_t) G__double(libp->para[9]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TProfile2D));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_307_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TProfile2D* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 9:
     //m: 9
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TProfile2D(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Option_t*) G__int(libp->para[8]));
     } else {
       p = new((void*) gvp) TProfile2D(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Option_t*) G__int(libp->para[8]));
     }
     break;
   case 8:
     //m: 8
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TProfile2D(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7]));
     } else {
       p = new((void*) gvp) TProfile2D(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TProfile2D));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_307_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TProfile2D* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 8:
     //m: 8
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TProfile2D(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Option_t*) G__int(libp->para[7]));
     } else {
       p = new((void*) gvp) TProfile2D(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Option_t*) G__int(libp->para[7]));
     }
     break;
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TProfile2D(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]));
     } else {
       p = new((void*) gvp) TProfile2D(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TProfile2D));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_307_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TProfile2D* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 8:
     //m: 8
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TProfile2D(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Double_t*) G__int(libp->para[6]), (Option_t*) G__int(libp->para[7]));
     } else {
       p = new((void*) gvp) TProfile2D(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Double_t*) G__int(libp->para[6]), (Option_t*) G__int(libp->para[7]));
     }
     break;
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TProfile2D(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Double_t*) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) TProfile2D(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Double_t*) G__int(libp->para[6]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TProfile2D));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_307_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TProfile2D* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TProfile2D(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5])
, (Option_t*) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) TProfile2D(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5])
, (Option_t*) G__int(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TProfile2D(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TProfile2D(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TProfile2D));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_307_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TProfile2D* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TProfile2D(*(TProfile2D*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TProfile2D(*(TProfile2D*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TProfile2D));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_307_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      TProfile2D::Approximate((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      TProfile2D::Approximate();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_307_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TProfile2D*) G__getstructoffset())->BuildOptions((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Option_t*) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_307_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TProfile2D*) G__getstructoffset())->Fill((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_307_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TProfile2D*) G__getstructoffset())->GetBinEntries((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_307_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TProfile2D*) G__getstructoffset())->GetBinEffectiveEntries((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_307_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TProfile2D*) G__getstructoffset())->GetBinSumw2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_307_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TProfile2D*) G__getstructoffset())->GetBinSumw2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_307_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TProfile2D*) G__getstructoffset())->GetErrorOption());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_307_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TProfile2D*) G__getstructoffset())->GetZmin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_307_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TProfile2D*) G__getstructoffset())->GetZmax());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_307_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 85, (long) ((const TProfile2D*) G__getstructoffset())->ProjectionXY((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((const TProfile2D*) G__getstructoffset())->ProjectionXY((const char*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((const TProfile2D*) G__getstructoffset())->ProjectionXY());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_307_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TProfile2D*) G__getstructoffset())->SetBinEntries((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_307_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TProfile2D*) G__getstructoffset())->SetErrorOption((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TProfile2D*) G__getstructoffset())->SetErrorOption();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_307_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TProfile2D::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_307_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TProfile2D::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_307_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TProfile2D::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_307_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TProfile2D::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_307_0_83(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TProfile2D*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_307_0_84(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TProfile2D::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_307_0_85(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TProfile2D::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_307_0_86(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TProfile2D::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_307_0_87(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TProfile2D::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TProfile2D G__TTProfile2D;
static int G__G__Hist_307_0_88(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TProfile2D*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TProfile2D*) (soff+(sizeof(TProfile2D)*i)))->~G__TTProfile2D();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TProfile2D*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TProfile2D*) (soff))->~G__TTProfile2D();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TH3 */
static int G__G__Hist_308_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH3* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH3(*(TH3*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TH3(*(TH3*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH3));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_308_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TH3*) G__getstructoffset())->Fill((Double_t) G__double(libp->para[0]), (const char*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_308_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TH3*) G__getstructoffset())->Fill((const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_308_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TH3*) G__getstructoffset())->Fill((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_308_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TH3*) G__getstructoffset())->Fill((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_308_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TH3*) G__getstructoffset())->Fill((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_308_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TH3*) G__getstructoffset())->Fill((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_308_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TH3*) G__getstructoffset())->Fill((const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (const char*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_308_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TH3*) G__getstructoffset())->Fill((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_308_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TH3*) G__getstructoffset())->Fill((Double_t) G__double(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_308_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TH3*) G__getstructoffset())->Fill((Double_t) G__double(libp->para[0]), (const char*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_308_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TH3*) G__getstructoffset())->Fill((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (const char*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_308_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 7:
      ((TH3*) G__getstructoffset())->FitSlicesZ(
(TF1*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Option_t*) G__int(libp->para[6]));
      G__setnull(result7);
      break;
   case 6:
      ((TH3*) G__getstructoffset())->FitSlicesZ((TF1*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
      G__setnull(result7);
      break;
   case 5:
      ((TH3*) G__getstructoffset())->FitSlicesZ((TF1*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TH3*) G__getstructoffset())->FitSlicesZ((TF1*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TH3*) G__getstructoffset())->FitSlicesZ((TF1*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TH3*) G__getstructoffset())->FitSlicesZ((TF1*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TH3*) G__getstructoffset())->FitSlicesZ((TF1*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TH3*) G__getstructoffset())->FitSlicesZ();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_308_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 11:
      G__letdouble(result7, 100, (double) ((const TH3*) G__getstructoffset())->GetBinWithContent3(
(Double_t) G__double(libp->para[0]), *(Int_t*) G__Intref(&libp->para[1])
, *(Int_t*) G__Intref(&libp->para[2]), *(Int_t*) G__Intref(&libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Int_t) G__int(libp->para[7])
, (Int_t) G__int(libp->para[8]), (Int_t) G__int(libp->para[9])
, (Double_t) G__double(libp->para[10])));
      break;
   case 10:
      G__letdouble(result7, 100, (double) ((const TH3*) G__getstructoffset())->GetBinWithContent3(
(Double_t) G__double(libp->para[0]), *(Int_t*) G__Intref(&libp->para[1])
, *(Int_t*) G__Intref(&libp->para[2]), *(Int_t*) G__Intref(&libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Int_t) G__int(libp->para[7])
, (Int_t) G__int(libp->para[8]), (Int_t) G__int(libp->para[9])));
      break;
   case 9:
      G__letdouble(result7, 100, (double) ((const TH3*) G__getstructoffset())->GetBinWithContent3(
(Double_t) G__double(libp->para[0]), *(Int_t*) G__Intref(&libp->para[1])
, *(Int_t*) G__Intref(&libp->para[2]), *(Int_t*) G__Intref(&libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Int_t) G__int(libp->para[7])
, (Int_t) G__int(libp->para[8])));
      break;
   case 8:
      G__letdouble(result7, 100, (double) ((const TH3*) G__getstructoffset())->GetBinWithContent3(
(Double_t) G__double(libp->para[0]), *(Int_t*) G__Intref(&libp->para[1])
, *(Int_t*) G__Intref(&libp->para[2]), *(Int_t*) G__Intref(&libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Int_t) G__int(libp->para[7])));
      break;
   case 7:
      G__letdouble(result7, 100, (double) ((const TH3*) G__getstructoffset())->GetBinWithContent3(
(Double_t) G__double(libp->para[0]), *(Int_t*) G__Intref(&libp->para[1])
, *(Int_t*) G__Intref(&libp->para[2]), *(Int_t*) G__Intref(&libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6])));
      break;
   case 6:
      G__letdouble(result7, 100, (double) ((const TH3*) G__getstructoffset())->GetBinWithContent3((Double_t) G__double(libp->para[0]), *(Int_t*) G__Intref(&libp->para[1])
, *(Int_t*) G__Intref(&libp->para[2]), *(Int_t*) G__Intref(&libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])));
      break;
   case 5:
      G__letdouble(result7, 100, (double) ((const TH3*) G__getstructoffset())->GetBinWithContent3((Double_t) G__double(libp->para[0]), *(Int_t*) G__Intref(&libp->para[1])
, *(Int_t*) G__Intref(&libp->para[2]), *(Int_t*) G__Intref(&libp->para[3])
, (Int_t) G__int(libp->para[4])));
      break;
   case 4:
      G__letdouble(result7, 100, (double) ((const TH3*) G__getstructoffset())->GetBinWithContent3((Double_t) G__double(libp->para[0]), *(Int_t*) G__Intref(&libp->para[1])
, *(Int_t*) G__Intref(&libp->para[2]), *(Int_t*) G__Intref(&libp->para[3])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_308_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letdouble(result7, 100, (double) ((const TH3*) G__getstructoffset())->GetCorrelationFactor((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((const TH3*) G__getstructoffset())->GetCorrelationFactor((Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TH3*) G__getstructoffset())->GetCorrelationFactor());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_308_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letdouble(result7, 100, (double) ((const TH3*) G__getstructoffset())->GetCovariance((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((const TH3*) G__getstructoffset())->GetCovariance((Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TH3*) G__getstructoffset())->GetCovariance());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_308_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TH3*) G__getstructoffset())->GetRandom3(*(Double_t*) G__Doubleref(&libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_308_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 7:
      G__letdouble(result7, 100, (double) ((const TH3*) G__getstructoffset())->Integral(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Option_t*) G__int(libp->para[6])));
      break;
   case 6:
      G__letdouble(result7, 100, (double) ((const TH3*) G__getstructoffset())->Integral((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_308_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 8:
      G__letdouble(result7, 100, (double) ((const TH3*) G__getstructoffset())->IntegralAndError(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, *(Double_t*) G__Doubleref(&libp->para[6]), (Option_t*) G__int(libp->para[7])));
      break;
   case 7:
      G__letdouble(result7, 100, (double) ((const TH3*) G__getstructoffset())->IntegralAndError(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, *(Double_t*) G__Doubleref(&libp->para[6])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_308_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 6:
      G__letint(result7, 85, (long) ((const TH3*) G__getstructoffset())->ProjectionX((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Option_t*) G__int(libp->para[5])));
      break;
   case 5:
      G__letint(result7, 85, (long) ((const TH3*) G__getstructoffset())->ProjectionX((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 85, (long) ((const TH3*) G__getstructoffset())->ProjectionX((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 85, (long) ((const TH3*) G__getstructoffset())->ProjectionX((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((const TH3*) G__getstructoffset())->ProjectionX((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((const TH3*) G__getstructoffset())->ProjectionX((const char*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((const TH3*) G__getstructoffset())->ProjectionX());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_308_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 6:
      G__letint(result7, 85, (long) ((const TH3*) G__getstructoffset())->ProjectionY((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Option_t*) G__int(libp->para[5])));
      break;
   case 5:
      G__letint(result7, 85, (long) ((const TH3*) G__getstructoffset())->ProjectionY((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 85, (long) ((const TH3*) G__getstructoffset())->ProjectionY((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 85, (long) ((const TH3*) G__getstructoffset())->ProjectionY((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((const TH3*) G__getstructoffset())->ProjectionY((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((const TH3*) G__getstructoffset())->ProjectionY((const char*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((const TH3*) G__getstructoffset())->ProjectionY());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_308_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 6:
      G__letint(result7, 85, (long) ((const TH3*) G__getstructoffset())->ProjectionZ((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Option_t*) G__int(libp->para[5])));
      break;
   case 5:
      G__letint(result7, 85, (long) ((const TH3*) G__getstructoffset())->ProjectionZ((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 85, (long) ((const TH3*) G__getstructoffset())->ProjectionZ((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 85, (long) ((const TH3*) G__getstructoffset())->ProjectionZ((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((const TH3*) G__getstructoffset())->ProjectionZ((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((const TH3*) G__getstructoffset())->ProjectionZ((const char*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((const TH3*) G__getstructoffset())->ProjectionZ());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_308_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 85, (long) ((const TH3*) G__getstructoffset())->Project3D((Option_t*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((const TH3*) G__getstructoffset())->Project3D());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_308_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 85, (long) ((const TH3*) G__getstructoffset())->Project3DProfile((Option_t*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((const TH3*) G__getstructoffset())->Project3DProfile());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_308_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TH3*) G__getstructoffset())->SetShowProjection((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TH3*) G__getstructoffset())->SetShowProjection((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TH3*) G__getstructoffset())->SetShowProjection();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_308_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TH3::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_308_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH3::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_308_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TH3::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_308_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TH3::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_308_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TH3*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_308_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH3::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_308_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TH3::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_308_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH3::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_308_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TH3::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TH3 G__TTH3;
static int G__G__Hist_308_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TH3*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TH3*) (soff+(sizeof(TH3)*i)))->~G__TTH3();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TH3*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TH3*) (soff))->~G__TTH3();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TH3C */
static int G__G__Hist_309_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH3C* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TH3C[n];
     } else {
       p = new((void*) gvp) TH3C[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TH3C;
     } else {
       p = new((void*) gvp) TH3C;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH3C));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_309_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH3C* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 11
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH3C(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Int_t) G__int(libp->para[8]), (Double_t) G__double(libp->para[9])
, (Double_t) G__double(libp->para[10]));
   } else {
     p = new((void*) gvp) TH3C(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Int_t) G__int(libp->para[8]), (Double_t) G__double(libp->para[9])
, (Double_t) G__double(libp->para[10]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH3C));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_309_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH3C* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 8
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH3C(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Float_t*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Float_t*) G__int(libp->para[7]));
   } else {
     p = new((void*) gvp) TH3C(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Float_t*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Float_t*) G__int(libp->para[7]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH3C));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_309_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH3C* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 8
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH3C(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Double_t*) G__int(libp->para[7]));
   } else {
     p = new((void*) gvp) TH3C(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Double_t*) G__int(libp->para[7]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH3C));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_309_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH3C* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH3C(*(TH3C*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TH3C(*(TH3C*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH3C));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_309_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TH3C& obj = ((TH3C*) G__getstructoffset())->operator=(*(TH3C*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_309_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TH3C::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_309_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH3C::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_309_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TH3C::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_309_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TH3C::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_309_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TH3C*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_309_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH3C::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_309_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TH3C::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_309_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH3C::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_309_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TH3C::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TH3C G__TTH3C;
static int G__G__Hist_309_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TH3C*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TH3C*) (soff+(sizeof(TH3C)*i)))->~G__TTH3C();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TH3C*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TH3C*) (soff))->~G__TTH3C();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TH3S */
static int G__G__Hist_310_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH3S* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TH3S[n];
     } else {
       p = new((void*) gvp) TH3S[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TH3S;
     } else {
       p = new((void*) gvp) TH3S;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH3S));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_310_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH3S* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 11
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH3S(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Int_t) G__int(libp->para[8]), (Double_t) G__double(libp->para[9])
, (Double_t) G__double(libp->para[10]));
   } else {
     p = new((void*) gvp) TH3S(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Int_t) G__int(libp->para[8]), (Double_t) G__double(libp->para[9])
, (Double_t) G__double(libp->para[10]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH3S));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_310_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH3S* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 8
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH3S(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Float_t*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Float_t*) G__int(libp->para[7]));
   } else {
     p = new((void*) gvp) TH3S(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Float_t*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Float_t*) G__int(libp->para[7]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH3S));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_310_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH3S* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 8
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH3S(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Double_t*) G__int(libp->para[7]));
   } else {
     p = new((void*) gvp) TH3S(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Double_t*) G__int(libp->para[7]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH3S));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_310_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH3S* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH3S(*(TH3S*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TH3S(*(TH3S*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH3S));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_310_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TH3S& obj = ((TH3S*) G__getstructoffset())->operator=(*(TH3S*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_310_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TH3S::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_310_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH3S::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_310_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TH3S::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_310_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TH3S::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_310_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TH3S*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_310_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH3S::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_310_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TH3S::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_310_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH3S::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_310_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TH3S::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TH3S G__TTH3S;
static int G__G__Hist_310_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TH3S*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TH3S*) (soff+(sizeof(TH3S)*i)))->~G__TTH3S();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TH3S*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TH3S*) (soff))->~G__TTH3S();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TH3I */
static int G__G__Hist_311_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH3I* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TH3I[n];
     } else {
       p = new((void*) gvp) TH3I[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TH3I;
     } else {
       p = new((void*) gvp) TH3I;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH3I));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_311_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH3I* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 11
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH3I(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Int_t) G__int(libp->para[8]), (Double_t) G__double(libp->para[9])
, (Double_t) G__double(libp->para[10]));
   } else {
     p = new((void*) gvp) TH3I(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Int_t) G__int(libp->para[8]), (Double_t) G__double(libp->para[9])
, (Double_t) G__double(libp->para[10]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH3I));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_311_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH3I* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 8
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH3I(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Float_t*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Float_t*) G__int(libp->para[7]));
   } else {
     p = new((void*) gvp) TH3I(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Float_t*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Float_t*) G__int(libp->para[7]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH3I));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_311_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH3I* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 8
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH3I(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Double_t*) G__int(libp->para[7]));
   } else {
     p = new((void*) gvp) TH3I(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Double_t*) G__int(libp->para[7]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH3I));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_311_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH3I* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH3I(*(TH3I*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TH3I(*(TH3I*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH3I));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_311_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TH3I& obj = ((TH3I*) G__getstructoffset())->operator=(*(TH3I*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_311_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TH3I::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_311_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH3I::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_311_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TH3I::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_311_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TH3I::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_311_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TH3I*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_311_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH3I::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_311_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TH3I::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_311_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH3I::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_311_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TH3I::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TH3I G__TTH3I;
static int G__G__Hist_311_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TH3I*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TH3I*) (soff+(sizeof(TH3I)*i)))->~G__TTH3I();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TH3I*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TH3I*) (soff))->~G__TTH3I();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TH3F */
static int G__G__Hist_312_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH3F* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TH3F[n];
     } else {
       p = new((void*) gvp) TH3F[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TH3F;
     } else {
       p = new((void*) gvp) TH3F;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH3F));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_312_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH3F* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 11
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH3F(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Int_t) G__int(libp->para[8]), (Double_t) G__double(libp->para[9])
, (Double_t) G__double(libp->para[10]));
   } else {
     p = new((void*) gvp) TH3F(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Int_t) G__int(libp->para[8]), (Double_t) G__double(libp->para[9])
, (Double_t) G__double(libp->para[10]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH3F));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_312_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH3F* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 8
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH3F(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Float_t*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Float_t*) G__int(libp->para[7]));
   } else {
     p = new((void*) gvp) TH3F(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Float_t*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Float_t*) G__int(libp->para[7]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH3F));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_312_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH3F* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 8
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH3F(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Double_t*) G__int(libp->para[7]));
   } else {
     p = new((void*) gvp) TH3F(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Double_t*) G__int(libp->para[7]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH3F));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_312_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH3F* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH3F(*(TH3F*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TH3F(*(TH3F*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH3F));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_312_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TH3F& obj = ((TH3F*) G__getstructoffset())->operator=(*(TH3F*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_312_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TH3F::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_312_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH3F::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_312_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TH3F::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_312_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TH3F::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_312_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TH3F*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_312_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH3F::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_312_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TH3F::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_312_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH3F::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_312_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TH3F::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TH3F G__TTH3F;
static int G__G__Hist_312_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TH3F*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TH3F*) (soff+(sizeof(TH3F)*i)))->~G__TTH3F();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TH3F*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TH3F*) (soff))->~G__TTH3F();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TH3D */
static int G__G__Hist_313_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH3D* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TH3D[n];
     } else {
       p = new((void*) gvp) TH3D[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TH3D;
     } else {
       p = new((void*) gvp) TH3D;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH3D));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_313_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH3D* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 11
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH3D(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Int_t) G__int(libp->para[8]), (Double_t) G__double(libp->para[9])
, (Double_t) G__double(libp->para[10]));
   } else {
     p = new((void*) gvp) TH3D(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Int_t) G__int(libp->para[8]), (Double_t) G__double(libp->para[9])
, (Double_t) G__double(libp->para[10]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH3D));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_313_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH3D* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 8
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH3D(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Float_t*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Float_t*) G__int(libp->para[7]));
   } else {
     p = new((void*) gvp) TH3D(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Float_t*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Float_t*) G__int(libp->para[7]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH3D));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_313_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH3D* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 8
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH3D(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Double_t*) G__int(libp->para[7]));
   } else {
     p = new((void*) gvp) TH3D(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Double_t*) G__int(libp->para[7]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH3D));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_313_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TH3D* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TH3D(*(TH3D*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TH3D(*(TH3D*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TH3D));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_313_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TH3D& obj = ((TH3D*) G__getstructoffset())->operator=(*(TH3D*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_313_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TH3D::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_313_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH3D::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_313_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TH3D::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_313_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TH3D::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_313_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TH3D*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_313_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH3D::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_313_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TH3D::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_313_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TH3D::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_313_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TH3D::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TH3D G__TTH3D;
static int G__G__Hist_313_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TH3D*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TH3D*) (soff+(sizeof(TH3D)*i)))->~G__TTH3D();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TH3D*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TH3D*) (soff))->~G__TTH3D();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* THLimitsFinder */
static int G__G__Hist_314_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   THLimitsFinder* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THLimitsFinder[n];
     } else {
       p = new((void*) gvp) THLimitsFinder[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THLimitsFinder;
     } else {
       p = new((void*) gvp) THLimitsFinder;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_THLimitsFinder));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_314_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((THLimitsFinder*) G__getstructoffset())->FindGoodLimits((TH1*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_314_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((THLimitsFinder*) G__getstructoffset())->FindGoodLimits((TH1*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_314_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((THLimitsFinder*) G__getstructoffset())->FindGoodLimits(
(TH1*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_314_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 8:
      THLimitsFinder::Optimize(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]), *(Double_t*) G__Doubleref(&libp->para[3])
, *(Double_t*) G__Doubleref(&libp->para[4]), *(Int_t*) G__Intref(&libp->para[5])
, *(Double_t*) G__Doubleref(&libp->para[6]), (Option_t*) G__int(libp->para[7]));
      G__setnull(result7);
      break;
   case 7:
      THLimitsFinder::Optimize(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]), *(Double_t*) G__Doubleref(&libp->para[3])
, *(Double_t*) G__Doubleref(&libp->para[4]), *(Int_t*) G__Intref(&libp->para[5])
, *(Double_t*) G__Doubleref(&libp->para[6]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_314_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      THLimitsFinder::OptimizeLimits((Int_t) G__int(libp->para[0]), *(Int_t*) G__Intref(&libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2]), *(Double_t*) G__Doubleref(&libp->para[3])
, (Bool_t) G__int(libp->para[4]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_314_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) THLimitsFinder::GetLimitsFinder());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_314_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      THLimitsFinder::SetLimitsFinder((THLimitsFinder*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_314_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) THLimitsFinder::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_314_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THLimitsFinder::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_314_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) THLimitsFinder::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_314_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      THLimitsFinder::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_314_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THLimitsFinder*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_314_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THLimitsFinder::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_314_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) THLimitsFinder::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_314_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THLimitsFinder::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_314_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) THLimitsFinder::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Hist_314_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   THLimitsFinder* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new THLimitsFinder(*(THLimitsFinder*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_THLimitsFinder));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef THLimitsFinder G__TTHLimitsFinder;
static int G__G__Hist_314_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (THLimitsFinder*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((THLimitsFinder*) (soff+(sizeof(THLimitsFinder)*i)))->~G__TTHLimitsFinder();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (THLimitsFinder*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((THLimitsFinder*) (soff))->~G__TTHLimitsFinder();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Hist_314_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   THLimitsFinder* dest = (THLimitsFinder*) G__getstructoffset();
   *dest = *(THLimitsFinder*) libp->para[0].ref;
   const THLimitsFinder& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* THnSparseArrayChunk */
static int G__G__Hist_319_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   THnSparseArrayChunk* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THnSparseArrayChunk[n];
     } else {
       p = new((void*) gvp) THnSparseArrayChunk[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THnSparseArrayChunk;
     } else {
       p = new((void*) gvp) THnSparseArrayChunk;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_THnSparseArrayChunk));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_319_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   THnSparseArrayChunk* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new THnSparseArrayChunk(
(Int_t) G__int(libp->para[0]), (bool) G__int(libp->para[1])
, (TArray*) G__int(libp->para[2]));
   } else {
     p = new((void*) gvp) THnSparseArrayChunk(
(Int_t) G__int(libp->para[0]), (bool) G__int(libp->para[1])
, (TArray*) G__int(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_THnSparseArrayChunk));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_319_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THnSparseArrayChunk*) G__getstructoffset())->AddBin((Int_t) G__int(libp->para[0]), (const Char_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_319_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((THnSparseArrayChunk*) G__getstructoffset())->AddBinContent((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((THnSparseArrayChunk*) G__getstructoffset())->AddBinContent((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_319_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THnSparseArrayChunk*) G__getstructoffset())->Sumw2();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_319_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const THnSparseArrayChunk*) G__getstructoffset())->GetEntries());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_319_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const THnSparseArrayChunk*) G__getstructoffset())->Matches((Int_t) G__int(libp->para[0]), (const Char_t*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_319_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) THnSparseArrayChunk::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_319_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THnSparseArrayChunk::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_319_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) THnSparseArrayChunk::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_319_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      THnSparseArrayChunk::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_319_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THnSparseArrayChunk*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_319_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THnSparseArrayChunk::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_319_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) THnSparseArrayChunk::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_319_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THnSparseArrayChunk::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_319_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) THnSparseArrayChunk::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef THnSparseArrayChunk G__TTHnSparseArrayChunk;
static int G__G__Hist_319_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (THnSparseArrayChunk*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((THnSparseArrayChunk*) (soff+(sizeof(THnSparseArrayChunk)*i)))->~G__TTHnSparseArrayChunk();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (THnSparseArrayChunk*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((THnSparseArrayChunk*) (soff))->~G__TTHnSparseArrayChunk();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* THnSparseT<TArrayD> */
static int G__G__Hist_322_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   THnSparseT<TArrayD>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THnSparseT<TArrayD>[n];
     } else {
       p = new((void*) gvp) THnSparseT<TArrayD>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THnSparseT<TArrayD>;
     } else {
       p = new((void*) gvp) THnSparseT<TArrayD>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArrayDgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_322_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   THnSparseT<TArrayD>* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THnSparseT<TArrayD>(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const Int_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) THnSparseT<TArrayD>(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const Int_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THnSparseT<TArrayD>(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const Int_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) THnSparseT<TArrayD>(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const Int_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THnSparseT<TArrayD>(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const Int_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) THnSparseT<TArrayD>(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const Int_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THnSparseT<TArrayD>(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const Int_t*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) THnSparseT<TArrayD>(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const Int_t*) G__int(libp->para[3]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArrayDgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_322_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) THnSparseT<TArrayD>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_322_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THnSparseT<TArrayD>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_322_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) THnSparseT<TArrayD>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_322_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      THnSparseT<TArrayD>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_322_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THnSparseT<TArrayD>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_322_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THnSparseT<TArrayD>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_322_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) THnSparseT<TArrayD>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_322_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THnSparseT<TArrayD>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_322_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) THnSparseT<TArrayD>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef THnSparseT<TArrayD> G__TTHnSparseTlETArrayDgR;
static int G__G__Hist_322_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (THnSparseT<TArrayD>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((THnSparseT<TArrayD>*) (soff+(sizeof(THnSparseT<TArrayD>)*i)))->~G__TTHnSparseTlETArrayDgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (THnSparseT<TArrayD>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((THnSparseT<TArrayD>*) (soff))->~G__TTHnSparseTlETArrayDgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* THnSparseT<TArrayF> */
static int G__G__Hist_323_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   THnSparseT<TArrayF>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THnSparseT<TArrayF>[n];
     } else {
       p = new((void*) gvp) THnSparseT<TArrayF>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THnSparseT<TArrayF>;
     } else {
       p = new((void*) gvp) THnSparseT<TArrayF>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArrayFgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_323_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   THnSparseT<TArrayF>* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THnSparseT<TArrayF>(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const Int_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) THnSparseT<TArrayF>(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const Int_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THnSparseT<TArrayF>(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const Int_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) THnSparseT<TArrayF>(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const Int_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THnSparseT<TArrayF>(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const Int_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) THnSparseT<TArrayF>(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const Int_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THnSparseT<TArrayF>(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const Int_t*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) THnSparseT<TArrayF>(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const Int_t*) G__int(libp->para[3]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArrayFgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_323_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) THnSparseT<TArrayF>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_323_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THnSparseT<TArrayF>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_323_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) THnSparseT<TArrayF>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_323_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      THnSparseT<TArrayF>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_323_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THnSparseT<TArrayF>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_323_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THnSparseT<TArrayF>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_323_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) THnSparseT<TArrayF>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_323_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THnSparseT<TArrayF>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_323_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) THnSparseT<TArrayF>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef THnSparseT<TArrayF> G__TTHnSparseTlETArrayFgR;
static int G__G__Hist_323_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (THnSparseT<TArrayF>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((THnSparseT<TArrayF>*) (soff+(sizeof(THnSparseT<TArrayF>)*i)))->~G__TTHnSparseTlETArrayFgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (THnSparseT<TArrayF>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((THnSparseT<TArrayF>*) (soff))->~G__TTHnSparseTlETArrayFgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* THnSparseT<TArrayL> */
static int G__G__Hist_324_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   THnSparseT<TArrayL>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THnSparseT<TArrayL>[n];
     } else {
       p = new((void*) gvp) THnSparseT<TArrayL>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THnSparseT<TArrayL>;
     } else {
       p = new((void*) gvp) THnSparseT<TArrayL>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArrayLgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_324_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   THnSparseT<TArrayL>* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THnSparseT<TArrayL>(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const Int_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) THnSparseT<TArrayL>(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const Int_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THnSparseT<TArrayL>(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const Int_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) THnSparseT<TArrayL>(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const Int_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THnSparseT<TArrayL>(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const Int_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) THnSparseT<TArrayL>(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const Int_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THnSparseT<TArrayL>(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const Int_t*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) THnSparseT<TArrayL>(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const Int_t*) G__int(libp->para[3]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArrayLgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_324_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) THnSparseT<TArrayL>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_324_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THnSparseT<TArrayL>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_324_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) THnSparseT<TArrayL>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_324_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      THnSparseT<TArrayL>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_324_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THnSparseT<TArrayL>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_324_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THnSparseT<TArrayL>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_324_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) THnSparseT<TArrayL>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_324_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THnSparseT<TArrayL>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_324_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) THnSparseT<TArrayL>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef THnSparseT<TArrayL> G__TTHnSparseTlETArrayLgR;
static int G__G__Hist_324_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (THnSparseT<TArrayL>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((THnSparseT<TArrayL>*) (soff+(sizeof(THnSparseT<TArrayL>)*i)))->~G__TTHnSparseTlETArrayLgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (THnSparseT<TArrayL>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((THnSparseT<TArrayL>*) (soff))->~G__TTHnSparseTlETArrayLgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* THnSparseT<TArrayI> */
static int G__G__Hist_325_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   THnSparseT<TArrayI>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THnSparseT<TArrayI>[n];
     } else {
       p = new((void*) gvp) THnSparseT<TArrayI>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THnSparseT<TArrayI>;
     } else {
       p = new((void*) gvp) THnSparseT<TArrayI>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArrayIgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_325_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   THnSparseT<TArrayI>* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THnSparseT<TArrayI>(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const Int_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) THnSparseT<TArrayI>(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const Int_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THnSparseT<TArrayI>(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const Int_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) THnSparseT<TArrayI>(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const Int_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THnSparseT<TArrayI>(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const Int_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) THnSparseT<TArrayI>(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const Int_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THnSparseT<TArrayI>(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const Int_t*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) THnSparseT<TArrayI>(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const Int_t*) G__int(libp->para[3]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArrayIgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_325_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) THnSparseT<TArrayI>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_325_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THnSparseT<TArrayI>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_325_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) THnSparseT<TArrayI>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_325_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      THnSparseT<TArrayI>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_325_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THnSparseT<TArrayI>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_325_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THnSparseT<TArrayI>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_325_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) THnSparseT<TArrayI>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_325_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THnSparseT<TArrayI>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_325_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) THnSparseT<TArrayI>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef THnSparseT<TArrayI> G__TTHnSparseTlETArrayIgR;
static int G__G__Hist_325_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (THnSparseT<TArrayI>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((THnSparseT<TArrayI>*) (soff+(sizeof(THnSparseT<TArrayI>)*i)))->~G__TTHnSparseTlETArrayIgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (THnSparseT<TArrayI>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((THnSparseT<TArrayI>*) (soff))->~G__TTHnSparseTlETArrayIgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* THnSparseT<TArrayS> */
static int G__G__Hist_326_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   THnSparseT<TArrayS>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THnSparseT<TArrayS>[n];
     } else {
       p = new((void*) gvp) THnSparseT<TArrayS>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THnSparseT<TArrayS>;
     } else {
       p = new((void*) gvp) THnSparseT<TArrayS>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArraySgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_326_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   THnSparseT<TArrayS>* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THnSparseT<TArrayS>(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const Int_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) THnSparseT<TArrayS>(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const Int_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THnSparseT<TArrayS>(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const Int_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) THnSparseT<TArrayS>(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const Int_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THnSparseT<TArrayS>(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const Int_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) THnSparseT<TArrayS>(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const Int_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THnSparseT<TArrayS>(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const Int_t*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) THnSparseT<TArrayS>(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const Int_t*) G__int(libp->para[3]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArraySgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_326_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) THnSparseT<TArrayS>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_326_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THnSparseT<TArrayS>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_326_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) THnSparseT<TArrayS>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_326_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      THnSparseT<TArrayS>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_326_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THnSparseT<TArrayS>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_326_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THnSparseT<TArrayS>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_326_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) THnSparseT<TArrayS>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_326_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THnSparseT<TArrayS>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_326_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) THnSparseT<TArrayS>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef THnSparseT<TArrayS> G__TTHnSparseTlETArraySgR;
static int G__G__Hist_326_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (THnSparseT<TArrayS>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((THnSparseT<TArrayS>*) (soff+(sizeof(THnSparseT<TArrayS>)*i)))->~G__TTHnSparseTlETArraySgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (THnSparseT<TArrayS>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((THnSparseT<TArrayS>*) (soff))->~G__TTHnSparseTlETArraySgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* THnSparseT<TArrayC> */
static int G__G__Hist_327_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   THnSparseT<TArrayC>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THnSparseT<TArrayC>[n];
     } else {
       p = new((void*) gvp) THnSparseT<TArrayC>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THnSparseT<TArrayC>;
     } else {
       p = new((void*) gvp) THnSparseT<TArrayC>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArrayCgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_327_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   THnSparseT<TArrayC>* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THnSparseT<TArrayC>(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const Int_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) THnSparseT<TArrayC>(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const Int_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THnSparseT<TArrayC>(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const Int_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) THnSparseT<TArrayC>(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const Int_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THnSparseT<TArrayC>(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const Int_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) THnSparseT<TArrayC>(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const Int_t*) G__int(libp->para[3])
, (Double_t*) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THnSparseT<TArrayC>(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const Int_t*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) THnSparseT<TArrayC>(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const Int_t*) G__int(libp->para[3]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArrayCgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_327_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) THnSparseT<TArrayC>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_327_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THnSparseT<TArrayC>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_327_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) THnSparseT<TArrayC>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_327_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      THnSparseT<TArrayC>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_327_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THnSparseT<TArrayC>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_327_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THnSparseT<TArrayC>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_327_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) THnSparseT<TArrayC>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_327_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THnSparseT<TArrayC>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_327_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) THnSparseT<TArrayC>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef THnSparseT<TArrayC> G__TTHnSparseTlETArrayCgR;
static int G__G__Hist_327_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (THnSparseT<TArrayC>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((THnSparseT<TArrayC>*) (soff+(sizeof(THnSparseT<TArrayC>)*i)))->~G__TTHnSparseTlETArrayCgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (THnSparseT<TArrayC>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((THnSparseT<TArrayC>*) (soff))->~G__TTHnSparseTlETArrayCgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* THStack */
static int G__G__Hist_328_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   THStack* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THStack[n];
     } else {
       p = new((void*) gvp) THStack[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THStack;
     } else {
       p = new((void*) gvp) THStack;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_THStack));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_328_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   THStack* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new THStack((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) THStack((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_THStack));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_328_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   THStack* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 10:
     //m: 10
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THStack(
(TH1*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Int_t) G__int(libp->para[7])
, (Option_t*) G__int(libp->para[8]), (Option_t*) G__int(libp->para[9]));
     } else {
       p = new((void*) gvp) THStack(
(TH1*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Int_t) G__int(libp->para[7])
, (Option_t*) G__int(libp->para[8]), (Option_t*) G__int(libp->para[9]));
     }
     break;
   case 9:
     //m: 9
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THStack(
(TH1*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Int_t) G__int(libp->para[7])
, (Option_t*) G__int(libp->para[8]));
     } else {
       p = new((void*) gvp) THStack(
(TH1*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Int_t) G__int(libp->para[7])
, (Option_t*) G__int(libp->para[8]));
     }
     break;
   case 8:
     //m: 8
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THStack(
(TH1*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Int_t) G__int(libp->para[7]));
     } else {
       p = new((void*) gvp) THStack(
(TH1*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Int_t) G__int(libp->para[7]));
     }
     break;
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THStack(
(TH1*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) THStack(
(TH1*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THStack(
(TH1*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) THStack(
(TH1*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THStack(
(TH1*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) THStack(
(TH1*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THStack(
(TH1*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) THStack(
(TH1*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THStack(
(TH1*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) THStack(
(TH1*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THStack((TH1*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) THStack((TH1*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THStack((TH1*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) THStack((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__G__HistLN_THStack));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_328_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   THStack* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new THStack(*(THStack*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) THStack(*(THStack*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_THStack));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_328_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((THStack*) G__getstructoffset())->Add((TH1*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((THStack*) G__getstructoffset())->Add((TH1*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_328_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const THStack*) G__getstructoffset())->GetHistogram());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_328_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const THStack*) G__getstructoffset())->GetHists());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_328_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((THStack*) G__getstructoffset())->GetStack());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_328_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((THStack*) G__getstructoffset())->GetMaximum((Option_t*) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((THStack*) G__getstructoffset())->GetMaximum());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_328_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((THStack*) G__getstructoffset())->GetMinimum((Option_t*) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((THStack*) G__getstructoffset())->GetMinimum());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_328_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const THStack*) G__getstructoffset())->GetXaxis());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_328_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const THStack*) G__getstructoffset())->GetYaxis());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_328_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THStack*) G__getstructoffset())->Modified();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_328_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THStack*) G__getstructoffset())->SetHistogram((TH1*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_328_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((THStack*) G__getstructoffset())->SetMaximum((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((THStack*) G__getstructoffset())->SetMaximum();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_328_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((THStack*) G__getstructoffset())->SetMinimum((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((THStack*) G__getstructoffset())->SetMinimum();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_328_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) THStack::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_328_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THStack::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_328_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) THStack::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_328_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      THStack::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_328_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THStack*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_328_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THStack::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_328_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) THStack::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_328_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THStack::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_328_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) THStack::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef THStack G__TTHStack;
static int G__G__Hist_328_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (THStack*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((THStack*) (soff+(sizeof(THStack)*i)))->~G__TTHStack();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (THStack*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((THStack*) (soff))->~G__TTHStack();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TKDE */
static int G__G__Hist_333_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TKDE* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TKDE(
(UInt_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Option_t*) G__int(libp->para[4]), (Double_t) G__double(libp->para[5]));
     } else {
       p = new((void*) gvp) TKDE(
(UInt_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Option_t*) G__int(libp->para[4]), (Double_t) G__double(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TKDE(
(UInt_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Option_t*) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TKDE(
(UInt_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Option_t*) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TKDE(
(UInt_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
     } else {
       p = new((void*) gvp) TKDE(
(UInt_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TKDE(
(UInt_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]));
     } else {
       p = new((void*) gvp) TKDE(
(UInt_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TKDE((UInt_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TKDE((UInt_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TKDE((UInt_t) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TKDE((UInt_t) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TKDE[n];
       } else {
         p = new((void*) gvp) TKDE[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TKDE;
       } else {
         p = new((void*) gvp) TKDE;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TKDE));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_333_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TKDE*) G__getstructoffset())->Fill((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_333_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TKDE*) G__getstructoffset())->SetKernelType((TKDE::EKernelType) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_333_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TKDE*) G__getstructoffset())->SetIteration((TKDE::EIteration) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_333_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TKDE*) G__getstructoffset())->SetMirror((TKDE::EMirror) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_333_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TKDE*) G__getstructoffset())->SetBinning((TKDE::EBinning) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_333_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TKDE*) G__getstructoffset())->SetNBins((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_333_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TKDE*) G__getstructoffset())->SetUseBinsNEvents((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_333_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TKDE*) G__getstructoffset())->SetTuneFactor((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_333_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TKDE*) G__getstructoffset())->SetRange((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_333_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TKDE*) G__getstructoffset())->operator()((Double_t) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_333_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) ((const TKDE*) G__getstructoffset())->operator()((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((const TKDE*) G__getstructoffset())->operator()((Double_t*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_333_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TKDE*) G__getstructoffset())->GetValue((Double_t) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_333_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TKDE*) G__getstructoffset())->GetError((Double_t) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_333_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TKDE*) G__getstructoffset())->GetBias((Double_t) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_333_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TKDE*) G__getstructoffset())->GetMean());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_333_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TKDE*) G__getstructoffset())->GetSigma());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_333_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TKDE*) G__getstructoffset())->GetRAMISE());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_333_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TKDE*) G__getstructoffset())->GetFixedWeight());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_333_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 85, (long) ((TKDE*) G__getstructoffset())->GetFunction((UInt_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((TKDE*) G__getstructoffset())->GetFunction((UInt_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TKDE*) G__getstructoffset())->GetFunction((UInt_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((TKDE*) G__getstructoffset())->GetFunction());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_333_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 85, (long) ((TKDE*) G__getstructoffset())->GetUpperFunction((Double_t) G__double(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 85, (long) ((TKDE*) G__getstructoffset())->GetUpperFunction((Double_t) G__double(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((TKDE*) G__getstructoffset())->GetUpperFunction((Double_t) G__double(libp->para[0]), (UInt_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TKDE*) G__getstructoffset())->GetUpperFunction((Double_t) G__double(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((TKDE*) G__getstructoffset())->GetUpperFunction());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_333_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 85, (long) ((TKDE*) G__getstructoffset())->GetLowerFunction((Double_t) G__double(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 85, (long) ((TKDE*) G__getstructoffset())->GetLowerFunction((Double_t) G__double(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((TKDE*) G__getstructoffset())->GetLowerFunction((Double_t) G__double(libp->para[0]), (UInt_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TKDE*) G__getstructoffset())->GetLowerFunction((Double_t) G__double(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((TKDE*) G__getstructoffset())->GetLowerFunction());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_333_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 85, (long) ((TKDE*) G__getstructoffset())->GetApproximateBias((UInt_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((TKDE*) G__getstructoffset())->GetApproximateBias((UInt_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TKDE*) G__getstructoffset())->GetApproximateBias((UInt_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((TKDE*) G__getstructoffset())->GetApproximateBias());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_333_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 85, (long) ((TKDE*) G__getstructoffset())->GetGraphWithErrors((UInt_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((TKDE*) G__getstructoffset())->GetGraphWithErrors((UInt_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TKDE*) G__getstructoffset())->GetGraphWithErrors((UInt_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((TKDE*) G__getstructoffset())->GetGraphWithErrors());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_333_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TKDE*) G__getstructoffset())->GetDrawnFunction());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_333_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TKDE*) G__getstructoffset())->GetDrawnUpperFunction());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_333_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TKDE*) G__getstructoffset())->GetDrawnLowerFunction());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_333_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TKDE*) G__getstructoffset())->GetDrawnGraph());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_333_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TKDE*) G__getstructoffset())->GetAdaptiveWeights());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_333_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TKDE::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_333_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TKDE::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_333_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TKDE::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_333_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TKDE::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_333_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TKDE*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_333_0_83(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TKDE::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_333_0_84(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TKDE::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_333_0_85(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TKDE::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_333_0_86(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TKDE::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TKDE G__TTKDE;
static int G__G__Hist_333_0_87(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TKDE*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TKDE*) (soff+(sizeof(TKDE)*i)))->~G__TTKDE();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TKDE*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TKDE*) (soff))->~G__TTKDE();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TLimitDataSource */
static int G__G__Hist_344_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TLimitDataSource* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TLimitDataSource[n];
     } else {
       p = new((void*) gvp) TLimitDataSource[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TLimitDataSource;
     } else {
       p = new((void*) gvp) TLimitDataSource;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TLimitDataSource));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_344_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TLimitDataSource* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TLimitDataSource(
(TH1*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
, (TH1*) G__int(libp->para[2]));
   } else {
     p = new((void*) gvp) TLimitDataSource(
(TH1*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
, (TH1*) G__int(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TLimitDataSource));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_344_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TLimitDataSource* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 6
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TLimitDataSource(
(TH1*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
, (TH1*) G__int(libp->para[2]), (TVectorD*) G__int(libp->para[3])
, (TVectorD*) G__int(libp->para[4]), (TObjArray*) G__int(libp->para[5]));
   } else {
     p = new((void*) gvp) TLimitDataSource(
(TH1*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
, (TH1*) G__int(libp->para[2]), (TVectorD*) G__int(libp->para[3])
, (TVectorD*) G__int(libp->para[4]), (TObjArray*) G__int(libp->para[5]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TLimitDataSource));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_344_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TLimitDataSource*) G__getstructoffset())->AddChannel((TH1*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
, (TH1*) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_344_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TLimitDataSource*) G__getstructoffset())->AddChannel((TH1*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
, (TH1*) G__int(libp->para[2]), (TVectorD*) G__int(libp->para[3])
, (TVectorD*) G__int(libp->para[4]), (TObjArray*) G__int(libp->para[5]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_344_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TLimitDataSource*) G__getstructoffset())->GetSignal());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_344_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TLimitDataSource*) G__getstructoffset())->GetBackground());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_344_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TLimitDataSource*) G__getstructoffset())->GetCandidates());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_344_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TLimitDataSource*) G__getstructoffset())->GetErrorOnSignal());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_344_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TLimitDataSource*) G__getstructoffset())->GetErrorOnBackground());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_344_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TLimitDataSource*) G__getstructoffset())->GetErrorNames());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_344_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TLimitDataSource*) G__getstructoffset())->SetOwner((bool) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TLimitDataSource*) G__getstructoffset())->SetOwner();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_344_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TLimitDataSource::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_344_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TLimitDataSource::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_344_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TLimitDataSource::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_344_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TLimitDataSource::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_344_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TLimitDataSource*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_344_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TLimitDataSource::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_344_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TLimitDataSource::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_344_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TLimitDataSource::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_344_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TLimitDataSource::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TLimitDataSource G__TTLimitDataSource;
static int G__G__Hist_344_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TLimitDataSource*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TLimitDataSource*) (soff+(sizeof(TLimitDataSource)*i)))->~G__TTLimitDataSource();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TLimitDataSource*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TLimitDataSource*) (soff))->~G__TTLimitDataSource();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TLimit */
static int G__G__Hist_347_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TLimit* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TLimit[n];
     } else {
       p = new((void*) gvp) TLimit[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TLimit;
     } else {
       p = new((void*) gvp) TLimit;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TLimit));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_347_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 85, (long) TLimit::ComputeLimit((TLimitDataSource*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (bool) G__int(libp->para[2]), (TRandom*) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 85, (long) TLimit::ComputeLimit((TLimitDataSource*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (bool) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) TLimit::ComputeLimit((TLimitDataSource*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) TLimit::ComputeLimit((TLimitDataSource*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_347_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 6:
      G__letint(result7, 85, (long) TLimit::ComputeLimit((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (bool) G__int(libp->para[4]), (TRandom*) G__int(libp->para[5])));
      break;
   case 5:
      G__letint(result7, 85, (long) TLimit::ComputeLimit((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (bool) G__int(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 85, (long) TLimit::ComputeLimit((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 85, (long) TLimit::ComputeLimit((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_347_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 9:
      G__letint(result7, 85, (long) TLimit::ComputeLimit(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TVectorD*) G__int(libp->para[3])
, (TVectorD*) G__int(libp->para[4]), (TObjArray*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (bool) G__int(libp->para[7])
, (TRandom*) G__int(libp->para[8])));
      break;
   case 8:
      G__letint(result7, 85, (long) TLimit::ComputeLimit(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TVectorD*) G__int(libp->para[3])
, (TVectorD*) G__int(libp->para[4]), (TObjArray*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (bool) G__int(libp->para[7])));
      break;
   case 7:
      G__letint(result7, 85, (long) TLimit::ComputeLimit(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TVectorD*) G__int(libp->para[3])
, (TVectorD*) G__int(libp->para[4]), (TObjArray*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6])));
      break;
   case 6:
      G__letint(result7, 85, (long) TLimit::ComputeLimit((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TVectorD*) G__int(libp->para[3])
, (TVectorD*) G__int(libp->para[4]), (TObjArray*) G__int(libp->para[5])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_347_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 6:
      G__letint(result7, 85, (long) TLimit::ComputeLimit((TH1*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
, (TH1*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (bool) G__int(libp->para[4]), (TRandom*) G__int(libp->para[5])));
      break;
   case 5:
      G__letint(result7, 85, (long) TLimit::ComputeLimit((TH1*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
, (TH1*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (bool) G__int(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 85, (long) TLimit::ComputeLimit((TH1*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
, (TH1*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 85, (long) TLimit::ComputeLimit((TH1*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
, (TH1*) G__int(libp->para[2])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_347_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 9:
      G__letint(result7, 85, (long) TLimit::ComputeLimit(
(TH1*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
, (TH1*) G__int(libp->para[2]), (TVectorD*) G__int(libp->para[3])
, (TVectorD*) G__int(libp->para[4]), (TObjArray*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (bool) G__int(libp->para[7])
, (TRandom*) G__int(libp->para[8])));
      break;
   case 8:
      G__letint(result7, 85, (long) TLimit::ComputeLimit(
(TH1*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
, (TH1*) G__int(libp->para[2]), (TVectorD*) G__int(libp->para[3])
, (TVectorD*) G__int(libp->para[4]), (TObjArray*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (bool) G__int(libp->para[7])));
      break;
   case 7:
      G__letint(result7, 85, (long) TLimit::ComputeLimit(
(TH1*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
, (TH1*) G__int(libp->para[2]), (TVectorD*) G__int(libp->para[3])
, (TVectorD*) G__int(libp->para[4]), (TObjArray*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6])));
      break;
   case 6:
      G__letint(result7, 85, (long) TLimit::ComputeLimit((TH1*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
, (TH1*) G__int(libp->para[2]), (TVectorD*) G__int(libp->para[3])
, (TVectorD*) G__int(libp->para[4]), (TObjArray*) G__int(libp->para[5])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_347_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TLimit::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_347_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TLimit::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_347_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TLimit::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_347_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TLimit::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_347_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TLimit*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_347_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TLimit*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_347_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TLimit*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_347_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TLimit*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_347_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TLimit::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_347_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TLimit::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_347_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TLimit::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_347_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TLimit::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Hist_347_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TLimit* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TLimit(*(TLimit*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TLimit));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TLimit G__TTLimit;
static int G__G__Hist_347_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[] (TLimit*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TLimit*) (soff+(sizeof(TLimit)*i)))->~G__TTLimit();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TLimit*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TLimit*) (soff))->~G__TTLimit();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Hist_347_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TLimit* dest = (TLimit*) G__getstructoffset();
   *dest = *(TLimit*) libp->para[0].ref;
   const TLimit& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMultiDimFit */
static int G__G__Hist_378_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMultiDimFit* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMultiDimFit[n];
     } else {
       p = new((void*) gvp) TMultiDimFit[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMultiDimFit;
     } else {
       p = new((void*) gvp) TMultiDimFit;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TMultiDimFit));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMultiDimFit* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMultiDimFit(
(Int_t) G__int(libp->para[0]), (TMultiDimFit::EMDFPolyType) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TMultiDimFit(
(Int_t) G__int(libp->para[0]), (TMultiDimFit::EMDFPolyType) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMultiDimFit((Int_t) G__int(libp->para[0]), (TMultiDimFit::EMDFPolyType) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TMultiDimFit((Int_t) G__int(libp->para[0]), (TMultiDimFit::EMDFPolyType) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMultiDimFit((Int_t) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TMultiDimFit((Int_t) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TMultiDimFit));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TMultiDimFit*) G__getstructoffset())->AddRow((Double_t*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TMultiDimFit*) G__getstructoffset())->AddRow((Double_t*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TMultiDimFit*) G__getstructoffset())->AddTestRow((Double_t*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TMultiDimFit*) G__getstructoffset())->AddTestRow((Double_t*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_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) ((const TMultiDimFit*) G__getstructoffset())->Eval((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((const TMultiDimFit*) G__getstructoffset())->Eval((Double_t*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letdouble(result7, 100, (double) ((const TMultiDimFit*) G__getstructoffset())->EvalError((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((const TMultiDimFit*) G__getstructoffset())->EvalError((Double_t*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TMultiDimFit*) G__getstructoffset())->FindParameterization((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TMultiDimFit*) G__getstructoffset())->FindParameterization();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TMultiDimFit*) G__getstructoffset())->Fit((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TMultiDimFit*) G__getstructoffset())->Fit();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMultiDimFit*) G__getstructoffset())->GetChi2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMultiDimFit*) G__getstructoffset())->GetCorrelationMatrix());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMultiDimFit*) G__getstructoffset())->GetCoefficients());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMultiDimFit*) G__getstructoffset())->GetError());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 73, (long) ((const TMultiDimFit*) G__getstructoffset())->GetFunctionCodes());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMultiDimFit*) G__getstructoffset())->GetFunctions());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMultiDimFit*) G__getstructoffset())->GetHistograms());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMultiDimFit*) G__getstructoffset())->GetMaxAngle());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMultiDimFit*) G__getstructoffset())->GetMaxFunctions());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 73, (long) ((const TMultiDimFit*) G__getstructoffset())->GetMaxPowers());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMultiDimFit*) G__getstructoffset())->GetMaxQuantity());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMultiDimFit*) G__getstructoffset())->GetMaxStudy());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMultiDimFit*) G__getstructoffset())->GetMaxTerms());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMultiDimFit*) G__getstructoffset())->GetMaxVariables());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMultiDimFit*) G__getstructoffset())->GetMeanQuantity());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMultiDimFit*) G__getstructoffset())->GetMeanVariables());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMultiDimFit*) G__getstructoffset())->GetMinAngle());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMultiDimFit*) G__getstructoffset())->GetMinQuantity());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMultiDimFit*) G__getstructoffset())->GetMinRelativeError());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMultiDimFit*) G__getstructoffset())->GetMinVariables());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMultiDimFit*) G__getstructoffset())->GetNVariables());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMultiDimFit*) G__getstructoffset())->GetNCoefficients());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMultiDimFit*) G__getstructoffset())->GetPolyType());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 73, (long) ((const TMultiDimFit*) G__getstructoffset())->GetPowerIndex());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMultiDimFit*) G__getstructoffset())->GetPowerLimit());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 73, (long) ((const TMultiDimFit*) G__getstructoffset())->GetPowers());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMultiDimFit*) G__getstructoffset())->GetPrecision());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMultiDimFit*) G__getstructoffset())->GetQuantity());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMultiDimFit*) G__getstructoffset())->GetResidualMax());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMultiDimFit*) G__getstructoffset())->GetResidualMin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMultiDimFit*) G__getstructoffset())->GetResidualMaxRow());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMultiDimFit*) G__getstructoffset())->GetResidualMinRow());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMultiDimFit*) G__getstructoffset())->GetResidualSumSq());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMultiDimFit*) G__getstructoffset())->GetRMS());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMultiDimFit*) G__getstructoffset())->GetSampleSize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMultiDimFit*) G__getstructoffset())->GetSqError());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMultiDimFit*) G__getstructoffset())->GetSumSqAvgQuantity());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMultiDimFit*) G__getstructoffset())->GetSumSqQuantity());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMultiDimFit*) G__getstructoffset())->GetTestError());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMultiDimFit*) G__getstructoffset())->GetTestPrecision());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMultiDimFit*) G__getstructoffset())->GetTestQuantity());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMultiDimFit*) G__getstructoffset())->GetTestSampleSize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMultiDimFit*) G__getstructoffset())->GetTestSqError());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMultiDimFit*) G__getstructoffset())->GetTestVariables());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMultiDimFit*) G__getstructoffset())->GetVariables());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMultiDimFit::Instance());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((TMultiDimFit*) G__getstructoffset())->MakeChi2((Double_t*) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((TMultiDimFit*) G__getstructoffset())->MakeChi2());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TMultiDimFit*) G__getstructoffset())->MakeCode((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TMultiDimFit*) G__getstructoffset())->MakeCode((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TMultiDimFit*) G__getstructoffset())->MakeCode();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TMultiDimFit*) G__getstructoffset())->MakeHistograms((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TMultiDimFit*) G__getstructoffset())->MakeHistograms();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TMultiDimFit*) G__getstructoffset())->MakeMethod((const Char_t*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TMultiDimFit*) G__getstructoffset())->MakeMethod((const Char_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TMultiDimFit*) G__getstructoffset())->MakeMethod();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMultiDimFit*) G__getstructoffset())->SetBinVarX((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMultiDimFit*) G__getstructoffset())->SetBinVarY((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TMultiDimFit*) G__getstructoffset())->SetMaxAngle((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TMultiDimFit*) G__getstructoffset())->SetMaxAngle();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMultiDimFit*) G__getstructoffset())->SetMaxFunctions((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMultiDimFit*) G__getstructoffset())->SetMaxPowers((const Int_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMultiDimFit*) G__getstructoffset())->SetMaxStudy((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMultiDimFit*) G__getstructoffset())->SetMaxTerms((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_83(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMultiDimFit*) G__getstructoffset())->SetMinRelativeError((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_84(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TMultiDimFit*) G__getstructoffset())->SetMinAngle((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TMultiDimFit*) G__getstructoffset())->SetMinAngle();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_85(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TMultiDimFit*) G__getstructoffset())->SetPowerLimit((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TMultiDimFit*) G__getstructoffset())->SetPowerLimit();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_86(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMultiDimFit*) G__getstructoffset())->SetPowers((const Int_t*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_87(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMultiDimFit::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_88(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMultiDimFit::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_89(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMultiDimFit::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_90(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMultiDimFit::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_94(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMultiDimFit*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_95(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMultiDimFit::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_96(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMultiDimFit::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_97(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMultiDimFit::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_378_0_98(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMultiDimFit::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Hist_378_0_99(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TMultiDimFit* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TMultiDimFit(*(TMultiDimFit*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TMultiDimFit));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMultiDimFit G__TTMultiDimFit;
static int G__G__Hist_378_0_100(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMultiDimFit*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMultiDimFit*) (soff+(sizeof(TMultiDimFit)*i)))->~G__TTMultiDimFit();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMultiDimFit*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMultiDimFit*) (soff))->~G__TTMultiDimFit();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Hist_378_0_101(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMultiDimFit* dest = (TMultiDimFit*) G__getstructoffset();
   *dest = *(TMultiDimFit*) libp->para[0].ref;
   const TMultiDimFit& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TPolyMarker */
static int G__G__Hist_380_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TPolyMarker* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TPolyMarker[n];
     } else {
       p = new((void*) gvp) TPolyMarker[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TPolyMarker;
     } else {
       p = new((void*) gvp) TPolyMarker;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TPolyMarker));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_380_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TPolyMarker* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TPolyMarker((Int_t) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TPolyMarker((Int_t) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TPolyMarker((Int_t) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TPolyMarker((Int_t) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TPolyMarker));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_380_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TPolyMarker* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TPolyMarker(
(Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TPolyMarker(
(Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TPolyMarker(
(Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TPolyMarker(
(Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TPolyMarker));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_380_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TPolyMarker* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TPolyMarker(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TPolyMarker(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TPolyMarker(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TPolyMarker(
(Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TPolyMarker));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_380_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TPolyMarker* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TPolyMarker(*(TPolyMarker*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TPolyMarker(*(TPolyMarker*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TPolyMarker));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_380_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TPolyMarker*) G__getstructoffset())->DrawPolyMarker((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TPolyMarker*) G__getstructoffset())->DrawPolyMarker((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_380_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TPolyMarker*) G__getstructoffset())->GetLastPoint());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_380_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TPolyMarker*) G__getstructoffset())->GetN());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_380_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TPolyMarker*) G__getstructoffset())->GetX());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_380_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TPolyMarker*) G__getstructoffset())->GetY());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_380_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TPolyMarker*) G__getstructoffset())->Merge((TCollection*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_380_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TPolyMarker*) G__getstructoffset())->PaintPolyMarker((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TPolyMarker*) G__getstructoffset())->PaintPolyMarker((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_380_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TPolyMarker*) G__getstructoffset())->SetNextPoint((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_380_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPolyMarker*) G__getstructoffset())->SetPoint((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_380_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPolyMarker*) G__getstructoffset())->SetPolyMarker((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_380_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TPolyMarker*) G__getstructoffset())->SetPolyMarker((Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TPolyMarker*) G__getstructoffset())->SetPolyMarker((Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_380_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TPolyMarker*) G__getstructoffset())->SetPolyMarker((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TPolyMarker*) G__getstructoffset())->SetPolyMarker((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_380_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TPolyMarker*) G__getstructoffset())->Size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_380_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TPolyMarker::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_380_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TPolyMarker::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_380_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TPolyMarker::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_380_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TPolyMarker::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_380_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPolyMarker*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_380_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TPolyMarker::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_380_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TPolyMarker::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_380_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TPolyMarker::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_380_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TPolyMarker::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TPolyMarker G__TTPolyMarker;
static int G__G__Hist_380_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TPolyMarker*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TPolyMarker*) (soff+(sizeof(TPolyMarker)*i)))->~G__TTPolyMarker();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TPolyMarker*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TPolyMarker*) (soff))->~G__TTPolyMarker();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TPrincipal */
static int G__G__Hist_381_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TPrincipal* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TPrincipal[n];
     } else {
       p = new((void*) gvp) TPrincipal[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TPrincipal;
     } else {
       p = new((void*) gvp) TPrincipal;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TPrincipal));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_381_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TPrincipal* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TPrincipal((Int_t) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TPrincipal((Int_t) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TPrincipal((Int_t) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TPrincipal((Int_t) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TPrincipal));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_381_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPrincipal*) G__getstructoffset())->AddRow((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_381_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TPrincipal*) G__getstructoffset())->GetCovarianceMatrix());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_381_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TPrincipal*) G__getstructoffset())->GetEigenValues());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_381_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TPrincipal*) G__getstructoffset())->GetEigenVectors());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_381_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TPrincipal*) G__getstructoffset())->GetHistograms());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_381_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TPrincipal*) G__getstructoffset())->GetMeanValues());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_381_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((TPrincipal*) G__getstructoffset())->GetRow((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_381_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TPrincipal*) G__getstructoffset())->GetSigmas());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_381_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TPrincipal*) G__getstructoffset())->GetUserData());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_381_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TPrincipal*) G__getstructoffset())->MakeCode((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TPrincipal*) G__getstructoffset())->MakeCode((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TPrincipal*) G__getstructoffset())->MakeCode();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_381_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TPrincipal*) G__getstructoffset())->MakeHistograms((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TPrincipal*) G__getstructoffset())->MakeHistograms((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TPrincipal*) G__getstructoffset())->MakeHistograms();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_381_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TPrincipal*) G__getstructoffset())->MakeMethods((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TPrincipal*) G__getstructoffset())->MakeMethods((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TPrincipal*) G__getstructoffset())->MakeMethods();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_381_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPrincipal*) G__getstructoffset())->MakePrincipals();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_381_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPrincipal*) G__getstructoffset())->P2X((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_381_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPrincipal*) G__getstructoffset())->SumOfSquareResiduals((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_381_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TPrincipal*) G__getstructoffset())->Test((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TPrincipal*) G__getstructoffset())->Test();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_381_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPrincipal*) G__getstructoffset())->X2P((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_381_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TPrincipal::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_381_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TPrincipal::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_381_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TPrincipal::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_381_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TPrincipal::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_381_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPrincipal*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_381_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TPrincipal::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_381_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TPrincipal::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_381_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TPrincipal::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_381_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TPrincipal::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TPrincipal G__TTPrincipal;
static int G__G__Hist_381_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TPrincipal*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TPrincipal*) (soff+(sizeof(TPrincipal)*i)))->~G__TTPrincipal();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TPrincipal*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TPrincipal*) (soff))->~G__TTPrincipal();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TProfile3D */
static int G__G__Hist_384_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TProfile3D* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TProfile3D[n];
     } else {
       p = new((void*) gvp) TProfile3D[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TProfile3D;
     } else {
       p = new((void*) gvp) TProfile3D;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TProfile3D));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_384_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TProfile3D* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 12:
     //m: 12
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TProfile3D(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Int_t) G__int(libp->para[8]), (Double_t) G__double(libp->para[9])
, (Double_t) G__double(libp->para[10]), (Option_t*) G__int(libp->para[11]));
     } else {
       p = new((void*) gvp) TProfile3D(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Int_t) G__int(libp->para[8]), (Double_t) G__double(libp->para[9])
, (Double_t) G__double(libp->para[10]), (Option_t*) G__int(libp->para[11]));
     }
     break;
   case 11:
     //m: 11
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TProfile3D(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Int_t) G__int(libp->para[8]), (Double_t) G__double(libp->para[9])
, (Double_t) G__double(libp->para[10]));
     } else {
       p = new((void*) gvp) TProfile3D(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Int_t) G__int(libp->para[8]), (Double_t) G__double(libp->para[9])
, (Double_t) G__double(libp->para[10]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TProfile3D));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_384_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TProfile3D* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 9:
     //m: 9
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TProfile3D(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Double_t*) G__int(libp->para[7])
, (Option_t*) G__int(libp->para[8]));
     } else {
       p = new((void*) gvp) TProfile3D(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Double_t*) G__int(libp->para[7])
, (Option_t*) G__int(libp->para[8]));
     }
     break;
   case 8:
     //m: 8
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TProfile3D(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Double_t*) G__int(libp->para[7]));
     } else {
       p = new((void*) gvp) TProfile3D(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Double_t*) G__int(libp->para[7]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TProfile3D));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_384_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TProfile3D* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TProfile3D(*(TProfile3D*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TProfile3D(*(TProfile3D*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TProfile3D));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_384_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      TProfile3D::Approximate((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      TProfile3D::Approximate();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_384_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TProfile3D*) G__getstructoffset())->BuildOptions((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Option_t*) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_384_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TProfile3D*) G__getstructoffset())->Fill((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_384_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TProfile3D*) G__getstructoffset())->GetBinEntries((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_384_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TProfile3D*) G__getstructoffset())->GetBinEffectiveEntries((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_384_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TProfile3D*) G__getstructoffset())->GetBinSumw2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_384_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TProfile3D*) G__getstructoffset())->GetBinSumw2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_384_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TProfile3D*) G__getstructoffset())->GetErrorOption());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_384_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TProfile3D*) G__getstructoffset())->GetTmin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_384_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TProfile3D*) G__getstructoffset())->GetTmax());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_384_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 85, (long) ((const TProfile3D*) G__getstructoffset())->ProjectionXYZ((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((const TProfile3D*) G__getstructoffset())->ProjectionXYZ((const char*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((const TProfile3D*) G__getstructoffset())->ProjectionXYZ());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_384_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TProfile3D*) G__getstructoffset())->SetBinEntries((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_384_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TProfile3D*) G__getstructoffset())->SetErrorOption((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TProfile3D*) G__getstructoffset())->SetErrorOption();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_384_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TProfile3D::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_384_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TProfile3D::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_384_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TProfile3D::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_384_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TProfile3D::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_384_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TProfile3D*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_384_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TProfile3D::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_384_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TProfile3D::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_384_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TProfile3D::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_384_0_83(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TProfile3D::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TProfile3D G__TTProfile3D;
static int G__G__Hist_384_0_84(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TProfile3D*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TProfile3D*) (soff+(sizeof(TProfile3D)*i)))->~G__TTProfile3D();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TProfile3D*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TProfile3D*) (soff))->~G__TTProfile3D();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TSplinePoly */
static int G__G__Hist_385_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TSplinePoly* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSplinePoly[n];
     } else {
       p = new((void*) gvp) TSplinePoly[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSplinePoly;
     } else {
       p = new((void*) gvp) TSplinePoly;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TSplinePoly));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_385_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TSplinePoly* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TSplinePoly((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
   } else {
     p = new((void*) gvp) TSplinePoly((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TSplinePoly));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_385_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TSplinePoly* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TSplinePoly(*(TSplinePoly*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TSplinePoly(*(TSplinePoly*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TSplinePoly));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_385_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TSplinePoly& obj = ((TSplinePoly*) G__getstructoffset())->operator=(*(TSplinePoly*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_385_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const Double_t& obj = ((TSplinePoly*) G__getstructoffset())->X();
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_385_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const Double_t& obj = ((TSplinePoly*) G__getstructoffset())->Y();
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_385_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TSplinePoly*) G__getstructoffset())->GetKnot(*(Double_t*) G__Doubleref(&libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_385_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TSplinePoly*) G__getstructoffset())->Eval((Double_t) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_385_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TSplinePoly::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_385_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSplinePoly::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_385_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TSplinePoly::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_385_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TSplinePoly::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_385_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSplinePoly*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_385_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSplinePoly::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_385_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TSplinePoly::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_385_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSplinePoly::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_385_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TSplinePoly::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TSplinePoly G__TTSplinePoly;
static int G__G__Hist_385_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TSplinePoly*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TSplinePoly*) (soff+(sizeof(TSplinePoly)*i)))->~G__TTSplinePoly();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TSplinePoly*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TSplinePoly*) (soff))->~G__TTSplinePoly();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TSplinePoly3 */
static int G__G__Hist_386_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TSplinePoly3* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSplinePoly3[n];
     } else {
       p = new((void*) gvp) TSplinePoly3[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSplinePoly3;
     } else {
       p = new((void*) gvp) TSplinePoly3;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TSplinePoly3));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_386_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TSplinePoly3* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 5
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TSplinePoly3(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
   } else {
     p = new((void*) gvp) TSplinePoly3(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TSplinePoly3));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_386_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TSplinePoly3* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TSplinePoly3(*(TSplinePoly3*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TSplinePoly3(*(TSplinePoly3*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TSplinePoly3));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_386_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TSplinePoly3& obj = ((TSplinePoly3*) G__getstructoffset())->operator=(*(TSplinePoly3*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_386_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const Double_t& obj = ((TSplinePoly3*) G__getstructoffset())->B();
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_386_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const Double_t& obj = ((TSplinePoly3*) G__getstructoffset())->C();
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_386_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const Double_t& obj = ((TSplinePoly3*) G__getstructoffset())->D();
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_386_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TSplinePoly3*) G__getstructoffset())->Derivative((Double_t) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_386_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TSplinePoly3::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_386_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSplinePoly3::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_386_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TSplinePoly3::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_386_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TSplinePoly3::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_386_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSplinePoly3*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_386_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSplinePoly3::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_386_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TSplinePoly3::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_386_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSplinePoly3::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_386_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TSplinePoly3::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TSplinePoly3 G__TTSplinePoly3;
static int G__G__Hist_386_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TSplinePoly3*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TSplinePoly3*) (soff+(sizeof(TSplinePoly3)*i)))->~G__TTSplinePoly3();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TSplinePoly3*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TSplinePoly3*) (soff))->~G__TTSplinePoly3();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TSplinePoly5 */
static int G__G__Hist_387_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TSplinePoly5* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSplinePoly5[n];
     } else {
       p = new((void*) gvp) TSplinePoly5[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSplinePoly5;
     } else {
       p = new((void*) gvp) TSplinePoly5;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TSplinePoly5));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_387_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TSplinePoly5* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 7
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TSplinePoly5(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]));
   } else {
     p = new((void*) gvp) TSplinePoly5(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TSplinePoly5));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_387_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TSplinePoly5* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TSplinePoly5(*(TSplinePoly5*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TSplinePoly5(*(TSplinePoly5*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TSplinePoly5));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_387_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TSplinePoly5& obj = ((TSplinePoly5*) G__getstructoffset())->operator=(*(TSplinePoly5*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_387_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const Double_t& obj = ((TSplinePoly5*) G__getstructoffset())->B();
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_387_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const Double_t& obj = ((TSplinePoly5*) G__getstructoffset())->C();
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_387_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const Double_t& obj = ((TSplinePoly5*) G__getstructoffset())->D();
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_387_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const Double_t& obj = ((TSplinePoly5*) G__getstructoffset())->E();
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_387_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const Double_t& obj = ((TSplinePoly5*) G__getstructoffset())->F();
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_387_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TSplinePoly5*) G__getstructoffset())->Derivative((Double_t) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_387_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TSplinePoly5::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_387_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSplinePoly5::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_387_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TSplinePoly5::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_387_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TSplinePoly5::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_387_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSplinePoly5*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_387_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSplinePoly5::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_387_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TSplinePoly5::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_387_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSplinePoly5::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_387_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TSplinePoly5::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TSplinePoly5 G__TTSplinePoly5;
static int G__G__Hist_387_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TSplinePoly5*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TSplinePoly5*) (soff+(sizeof(TSplinePoly5)*i)))->~G__TTSplinePoly5();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TSplinePoly5*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TSplinePoly5*) (soff))->~G__TTSplinePoly5();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TSpline3 */
static int G__G__Hist_388_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TSpline3* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSpline3[n];
     } else {
       p = new((void*) gvp) TSpline3[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSpline3;
     } else {
       p = new((void*) gvp) TSpline3;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TSpline3));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_388_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TSpline3* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSpline3(
(const char*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]));
     } else {
       p = new((void*) gvp) TSpline3(
(const char*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSpline3(
(const char*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (Double_t) G__double(libp->para[5]));
     } else {
       p = new((void*) gvp) TSpline3(
(const char*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (Double_t) G__double(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSpline3(
(const char*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TSpline3(
(const char*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSpline3(
(const char*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TSpline3(
(const char*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TSpline3));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_388_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TSpline3* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 8:
     //m: 8
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSpline3(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7]));
     } else {
       p = new((void*) gvp) TSpline3(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7]));
     }
     break;
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSpline3(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]));
     } else {
       p = new((void*) gvp) TSpline3(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSpline3(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (const char*) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TSpline3(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (const char*) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSpline3(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TSpline3(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TSpline3));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_388_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TSpline3* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSpline3(
(const char*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (TF1*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]));
     } else {
       p = new((void*) gvp) TSpline3(
(const char*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (TF1*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSpline3(
(const char*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (TF1*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (Double_t) G__double(libp->para[5]));
     } else {
       p = new((void*) gvp) TSpline3(
(const char*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (TF1*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (Double_t) G__double(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSpline3(
(const char*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (TF1*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TSpline3(
(const char*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (TF1*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSpline3(
(const char*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (TF1*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TSpline3(
(const char*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (TF1*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TSpline3));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_388_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TSpline3* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 8:
     //m: 8
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSpline3(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (TF1*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7]));
     } else {
       p = new((void*) gvp) TSpline3(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (TF1*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7]));
     }
     break;
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSpline3(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (TF1*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]));
     } else {
       p = new((void*) gvp) TSpline3(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (TF1*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSpline3(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (TF1*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (const char*) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TSpline3(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (TF1*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (const char*) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSpline3(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (TF1*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TSpline3(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (TF1*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TSpline3));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_388_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TSpline3* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSpline3(
(const char*) G__int(libp->para[0]), (TGraph*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
     } else {
       p = new((void*) gvp) TSpline3(
(const char*) G__int(libp->para[0]), (TGraph*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSpline3(
(const char*) G__int(libp->para[0]), (TGraph*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3]));
     } else {
       p = new((void*) gvp) TSpline3(
(const char*) G__int(libp->para[0]), (TGraph*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSpline3(
(const char*) G__int(libp->para[0]), (TGraph*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TSpline3(
(const char*) G__int(libp->para[0]), (TGraph*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSpline3((const char*) G__int(libp->para[0]), (TGraph*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TSpline3((const char*) G__int(libp->para[0]), (TGraph*) G__int(libp->para[1]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TSpline3));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_388_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TSpline3* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSpline3(
(TH1*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
     } else {
       p = new((void*) gvp) TSpline3(
(TH1*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSpline3(
(TH1*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]));
     } else {
       p = new((void*) gvp) TSpline3(
(TH1*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSpline3((TH1*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TSpline3((TH1*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSpline3((TH1*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TSpline3((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__G__HistLN_TSpline3));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_388_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TSpline3* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TSpline3(*(TSpline3*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TSpline3(*(TSpline3*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TSpline3));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_388_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TSpline3& obj = ((TSpline3*) G__getstructoffset())->operator=(*(TSpline3*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_388_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TSpline3*) G__getstructoffset())->FindX((Double_t) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_388_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TSpline3*) G__getstructoffset())->Derivative((Double_t) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_388_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSpline3*) G__getstructoffset())->GetCoeff((Int_t) G__int(libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2]), *(Double_t*) G__Doubleref(&libp->para[3])
, *(Double_t*) G__Doubleref(&libp->para[4]), *(Double_t*) G__Doubleref(&libp->para[5]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_388_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((const TSpline3*) G__getstructoffset())->SaveAs((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((const TSpline3*) G__getstructoffset())->SaveAs((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_388_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSpline3*) G__getstructoffset())->SetPoint((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_388_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSpline3*) G__getstructoffset())->SetPointCoeff((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_388_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TSpline3::Test();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_388_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TSpline3::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_388_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSpline3::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_388_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TSpline3::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_388_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TSpline3::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_388_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSpline3*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_388_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSpline3::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_388_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TSpline3::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_388_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSpline3::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_388_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TSpline3::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TSpline3 G__TTSpline3;
static int G__G__Hist_388_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TSpline3*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TSpline3*) (soff+(sizeof(TSpline3)*i)))->~G__TTSpline3();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TSpline3*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TSpline3*) (soff))->~G__TTSpline3();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TSpline5 */
static int G__G__Hist_389_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TSpline5* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSpline5[n];
     } else {
       p = new((void*) gvp) TSpline5[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSpline5;
     } else {
       p = new((void*) gvp) TSpline5;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TSpline5));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_389_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TSpline5* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 9:
     //m: 9
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSpline5(
(const char*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]));
     } else {
       p = new((void*) gvp) TSpline5(
(const char*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]));
     }
     break;
   case 8:
     //m: 8
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSpline5(
(const char*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7]));
     } else {
       p = new((void*) gvp) TSpline5(
(const char*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7]));
     }
     break;
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSpline5(
(const char*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]));
     } else {
       p = new((void*) gvp) TSpline5(
(const char*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSpline5(
(const char*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (Double_t) G__double(libp->para[5]));
     } else {
       p = new((void*) gvp) TSpline5(
(const char*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (Double_t) G__double(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSpline5(
(const char*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TSpline5(
(const char*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSpline5(
(const char*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TSpline5(
(const char*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TSpline5));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_389_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TSpline5* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 10:
     //m: 10
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSpline5(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]), (Double_t) G__double(libp->para[9]));
     } else {
       p = new((void*) gvp) TSpline5(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]), (Double_t) G__double(libp->para[9]));
     }
     break;
   case 9:
     //m: 9
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSpline5(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]));
     } else {
       p = new((void*) gvp) TSpline5(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]));
     }
     break;
   case 8:
     //m: 8
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSpline5(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7]));
     } else {
       p = new((void*) gvp) TSpline5(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7]));
     }
     break;
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSpline5(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]));
     } else {
       p = new((void*) gvp) TSpline5(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSpline5(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (const char*) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TSpline5(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (const char*) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSpline5(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TSpline5(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TSpline5));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_389_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TSpline5* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 9:
     //m: 9
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSpline5(
(const char*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (TF1*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]));
     } else {
       p = new((void*) gvp) TSpline5(
(const char*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (TF1*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]));
     }
     break;
   case 8:
     //m: 8
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSpline5(
(const char*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (TF1*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7]));
     } else {
       p = new((void*) gvp) TSpline5(
(const char*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (TF1*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7]));
     }
     break;
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSpline5(
(const char*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (TF1*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]));
     } else {
       p = new((void*) gvp) TSpline5(
(const char*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (TF1*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSpline5(
(const char*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (TF1*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (Double_t) G__double(libp->para[5]));
     } else {
       p = new((void*) gvp) TSpline5(
(const char*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (TF1*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (Double_t) G__double(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSpline5(
(const char*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (TF1*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TSpline5(
(const char*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (TF1*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSpline5(
(const char*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (TF1*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TSpline5(
(const char*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (TF1*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TSpline5));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_389_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TSpline5* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 10:
     //m: 10
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSpline5(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (TF1*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]), (Double_t) G__double(libp->para[9]));
     } else {
       p = new((void*) gvp) TSpline5(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (TF1*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]), (Double_t) G__double(libp->para[9]));
     }
     break;
   case 9:
     //m: 9
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSpline5(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (TF1*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]));
     } else {
       p = new((void*) gvp) TSpline5(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (TF1*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]));
     }
     break;
   case 8:
     //m: 8
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSpline5(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (TF1*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7]));
     } else {
       p = new((void*) gvp) TSpline5(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (TF1*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7]));
     }
     break;
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSpline5(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (TF1*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]));
     } else {
       p = new((void*) gvp) TSpline5(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (TF1*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSpline5(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (TF1*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (const char*) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TSpline5(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (TF1*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (const char*) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSpline5(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (TF1*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TSpline5(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (TF1*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TSpline5));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_389_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TSpline5* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSpline5(
(const char*) G__int(libp->para[0]), (TGraph*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]));
     } else {
       p = new((void*) gvp) TSpline5(
(const char*) G__int(libp->para[0]), (TGraph*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSpline5(
(const char*) G__int(libp->para[0]), (TGraph*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
     } else {
       p = new((void*) gvp) TSpline5(
(const char*) G__int(libp->para[0]), (TGraph*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSpline5(
(const char*) G__int(libp->para[0]), (TGraph*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
     } else {
       p = new((void*) gvp) TSpline5(
(const char*) G__int(libp->para[0]), (TGraph*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSpline5(
(const char*) G__int(libp->para[0]), (TGraph*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3]));
     } else {
       p = new((void*) gvp) TSpline5(
(const char*) G__int(libp->para[0]), (TGraph*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSpline5(
(const char*) G__int(libp->para[0]), (TGraph*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TSpline5(
(const char*) G__int(libp->para[0]), (TGraph*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSpline5((const char*) G__int(libp->para[0]), (TGraph*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TSpline5((const char*) G__int(libp->para[0]), (TGraph*) G__int(libp->para[1]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TSpline5));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_389_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TSpline5* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSpline5(
(TH1*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
     } else {
       p = new((void*) gvp) TSpline5(
(TH1*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSpline5(
(TH1*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
     } else {
       p = new((void*) gvp) TSpline5(
(TH1*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSpline5(
(TH1*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
     } else {
       p = new((void*) gvp) TSpline5(
(TH1*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSpline5(
(TH1*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]));
     } else {
       p = new((void*) gvp) TSpline5(
(TH1*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSpline5((TH1*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TSpline5((TH1*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSpline5((TH1*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TSpline5((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__G__HistLN_TSpline5));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_389_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TSpline5* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TSpline5(*(TSpline5*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TSpline5(*(TSpline5*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TSpline5));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_389_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TSpline5& obj = ((TSpline5*) G__getstructoffset())->operator=(*(TSpline5*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_389_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TSpline5*) G__getstructoffset())->FindX((Double_t) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_389_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TSpline5*) G__getstructoffset())->Derivative((Double_t) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_389_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSpline5*) G__getstructoffset())->GetCoeff(
(Int_t) G__int(libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2]), *(Double_t*) G__Doubleref(&libp->para[3])
, *(Double_t*) G__Doubleref(&libp->para[4]), *(Double_t*) G__Doubleref(&libp->para[5])
, *(Double_t*) G__Doubleref(&libp->para[6]), *(Double_t*) G__Doubleref(&libp->para[7]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_389_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((const TSpline5*) G__getstructoffset())->SaveAs((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((const TSpline5*) G__getstructoffset())->SaveAs((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_389_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSpline5*) G__getstructoffset())->SetPoint((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_389_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSpline5*) G__getstructoffset())->SetPointCoeff((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_389_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TSpline5::Test();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_389_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TSpline5::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_389_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSpline5::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_389_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TSpline5::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_389_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TSpline5::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_389_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSpline5*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_389_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSpline5::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_389_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TSpline5::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_389_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSpline5::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_389_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TSpline5::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TSpline5 G__TTSpline5;
static int G__G__Hist_389_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: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TSpline5*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TSpline5*) (soff+(sizeof(TSpline5)*i)))->~G__TTSpline5();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TSpline5*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TSpline5*) (soff))->~G__TTSpline5();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TSVDUnfold */
static int G__G__Hist_390_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TSVDUnfold* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TSVDUnfold(
(TH1D*) G__int(libp->para[0]), (TH1D*) G__int(libp->para[1])
, (TH1D*) G__int(libp->para[2]), (TH2D*) G__int(libp->para[3]));
   } else {
     p = new((void*) gvp) TSVDUnfold(
(TH1D*) G__int(libp->para[0]), (TH1D*) G__int(libp->para[1])
, (TH1D*) G__int(libp->para[2]), (TH2D*) G__int(libp->para[3]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TSVDUnfold));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_390_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TSVDUnfold* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TSVDUnfold(*(TSVDUnfold*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TSVDUnfold(*(TSVDUnfold*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TSVDUnfold));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_390_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSVDUnfold*) G__getstructoffset())->SetNormalize((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_390_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TSVDUnfold*) G__getstructoffset())->Unfold((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_390_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 85, (long) ((TSVDUnfold*) G__getstructoffset())->GetUnfoldCovMatrix((TH2D*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((TSVDUnfold*) G__getstructoffset())->GetUnfoldCovMatrix((TH2D*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_390_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 85, (long) ((TSVDUnfold*) G__getstructoffset())->GetAdetCovMatrix((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TSVDUnfold*) G__getstructoffset())->GetAdetCovMatrix((Int_t) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_390_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TSVDUnfold*) G__getstructoffset())->GetKReg());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_390_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TSVDUnfold*) G__getstructoffset())->GetD());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_390_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TSVDUnfold*) G__getstructoffset())->GetSV());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_390_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letdouble(result7, 100, (double) TSVDUnfold::ComputeChiSquared(*(TH1D*) libp->para[0].ref, *(TH1D*) libp->para[1].ref
, *(TH2D*) libp->para[2].ref, (Double_t) G__double(libp->para[3])));
      break;
   case 3:
      G__letdouble(result7, 100, (double) TSVDUnfold::ComputeChiSquared(*(TH1D*) libp->para[0].ref, *(TH1D*) libp->para[1].ref
, *(TH2D*) libp->para[2].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_390_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TSVDUnfold::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_390_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSVDUnfold::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_390_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TSVDUnfold::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_390_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TSVDUnfold::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_390_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSVDUnfold*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_390_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSVDUnfold::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_390_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TSVDUnfold::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_390_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSVDUnfold::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_390_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TSVDUnfold::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TSVDUnfold G__TTSVDUnfold;
static int G__G__Hist_390_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TSVDUnfold*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TSVDUnfold*) (soff+(sizeof(TSVDUnfold)*i)))->~G__TTSVDUnfold();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TSVDUnfold*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TSVDUnfold*) (soff))->~G__TTSVDUnfold();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TUnfold */
static int G__G__Hist_391_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TUnfold* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TUnfold(
(TH2*) G__int(libp->para[0]), (TUnfold::EHistMap) G__int(libp->para[1])
, (TUnfold::ERegMode) G__int(libp->para[2]), (TUnfold::EConstraint) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TUnfold(
(TH2*) G__int(libp->para[0]), (TUnfold::EHistMap) G__int(libp->para[1])
, (TUnfold::ERegMode) G__int(libp->para[2]), (TUnfold::EConstraint) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TUnfold(
(TH2*) G__int(libp->para[0]), (TUnfold::EHistMap) G__int(libp->para[1])
, (TUnfold::ERegMode) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TUnfold(
(TH2*) G__int(libp->para[0]), (TUnfold::EHistMap) G__int(libp->para[1])
, (TUnfold::ERegMode) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TUnfold((TH2*) G__int(libp->para[0]), (TUnfold::EHistMap) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TUnfold((TH2*) G__int(libp->para[0]), (TUnfold::EHistMap) G__int(libp->para[1]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TUnfold));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_391_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TUnfold::GetTUnfoldVersion());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_391_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TUnfold*) G__getstructoffset())->SetBias((TH1*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_391_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TUnfold*) G__getstructoffset())->SetConstraint((TUnfold::EConstraint) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_391_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 105, (long) ((TUnfold*) G__getstructoffset())->RegularizeSize((int) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((TUnfold*) G__getstructoffset())->RegularizeSize((int) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_391_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 105, (long) ((TUnfold*) G__getstructoffset())->RegularizeDerivative((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 105, (long) ((TUnfold*) G__getstructoffset())->RegularizeDerivative((int) G__int(libp->para[0]), (int) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_391_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letint(result7, 105, (long) ((TUnfold*) G__getstructoffset())->RegularizeCurvature((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
, (int) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 105, (long) ((TUnfold*) G__getstructoffset())->RegularizeCurvature((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
, (int) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 105, (long) ((TUnfold*) G__getstructoffset())->RegularizeCurvature((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
, (int) G__int(libp->para[2])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_391_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TUnfold*) G__getstructoffset())->RegularizeBins((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
, (int) G__int(libp->para[2]), (TUnfold::ERegMode) G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_391_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TUnfold*) G__getstructoffset())->RegularizeBins2D((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
, (int) G__int(libp->para[2]), (int) G__int(libp->para[3])
, (int) G__int(libp->para[4]), (TUnfold::ERegMode) G__int(libp->para[5])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_391_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letdouble(result7, 100, (double) ((TUnfold*) G__getstructoffset())->DoUnfold((Double_t) G__double(libp->para[0]), (TH1*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2])));
      break;
   case 2:
      G__letdouble(result7, 100, (double) ((TUnfold*) G__getstructoffset())->DoUnfold((Double_t) G__double(libp->para[0]), (TH1*) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_391_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 105, (long) ((TUnfold*) G__getstructoffset())->SetInput((TH1*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 105, (long) ((TUnfold*) G__getstructoffset())->SetInput((TH1*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((TUnfold*) G__getstructoffset())->SetInput((TH1*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_391_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TUnfold*) G__getstructoffset())->DoUnfold((Double_t) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_391_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 6:
      G__letint(result7, 105, (long) ((TUnfold*) G__getstructoffset())->ScanLcurve((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (TGraph**) G__int(libp->para[3])
, (TSpline**) G__int(libp->para[4]), (TSpline**) G__int(libp->para[5])));
      break;
   case 5:
      G__letint(result7, 105, (long) ((TUnfold*) G__getstructoffset())->ScanLcurve((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (TGraph**) G__int(libp->para[3])
, (TSpline**) G__int(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 105, (long) ((TUnfold*) G__getstructoffset())->ScanLcurve((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (TGraph**) G__int(libp->para[3])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_391_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 85, (long) ((const TUnfold*) G__getstructoffset())->GetOutput((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 85, (long) ((const TUnfold*) G__getstructoffset())->GetOutput((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((const TUnfold*) G__getstructoffset())->GetOutput((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_391_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 85, (long) ((const TUnfold*) G__getstructoffset())->GetBias((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 85, (long) ((const TUnfold*) G__getstructoffset())->GetBias((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((const TUnfold*) G__getstructoffset())->GetBias((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_391_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 85, (long) ((const TUnfold*) G__getstructoffset())->GetFoldedOutput((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 85, (long) ((const TUnfold*) G__getstructoffset())->GetFoldedOutput((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((const TUnfold*) G__getstructoffset())->GetFoldedOutput((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_391_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 85, (long) ((const TUnfold*) G__getstructoffset())->GetInput((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 85, (long) ((const TUnfold*) G__getstructoffset())->GetInput((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((const TUnfold*) G__getstructoffset())->GetInput((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_391_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 85, (long) ((const TUnfold*) G__getstructoffset())->GetRhoIJ((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 85, (long) ((const TUnfold*) G__getstructoffset())->GetRhoIJ((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((const TUnfold*) G__getstructoffset())->GetRhoIJ((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_391_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 85, (long) ((const TUnfold*) G__getstructoffset())->GetEmatrix((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 85, (long) ((const TUnfold*) G__getstructoffset())->GetEmatrix((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((const TUnfold*) G__getstructoffset())->GetEmatrix((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_391_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 85, (long) ((const TUnfold*) G__getstructoffset())->GetRhoI((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 85, (long) ((const TUnfold*) G__getstructoffset())->GetRhoI((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((const TUnfold*) G__getstructoffset())->GetRhoI((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_391_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 85, (long) ((const TUnfold*) G__getstructoffset())->GetLsquared((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 85, (long) ((const TUnfold*) G__getstructoffset())->GetLsquared((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((const TUnfold*) G__getstructoffset())->GetLsquared((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_391_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((const TUnfold*) G__getstructoffset())->GetOutput((TH1*) G__int(libp->para[0]), (const Int_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((const TUnfold*) G__getstructoffset())->GetOutput((TH1*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_391_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((const TUnfold*) G__getstructoffset())->GetEmatrix((TH2*) G__int(libp->para[0]), (const Int_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((const TUnfold*) G__getstructoffset())->GetEmatrix((TH2*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_391_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letdouble(result7, 100, (double) ((const TUnfold*) G__getstructoffset())->GetRhoI((TH1*) G__int(libp->para[0]), (TH2*) G__int(libp->para[1])
, (const Int_t*) G__int(libp->para[2])));
      break;
   case 2:
      G__letdouble(result7, 100, (double) ((const TUnfold*) G__getstructoffset())->GetRhoI((TH1*) G__int(libp->para[0]), (TH2*) G__int(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((const TUnfold*) G__getstructoffset())->GetRhoI((TH1*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_391_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((const TUnfold*) G__getstructoffset())->GetRhoIJ((TH2*) G__int(libp->para[0]), (const Int_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((const TUnfold*) G__getstructoffset())->GetRhoIJ((TH2*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_391_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TUnfold*) G__getstructoffset())->GetTau());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_391_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TUnfold*) G__getstructoffset())->GetRhoMax());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_391_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TUnfold*) G__getstructoffset())->GetRhoAvg());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_391_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TUnfold*) G__getstructoffset())->GetChi2A());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_391_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TUnfold*) G__getstructoffset())->GetChi2L());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_391_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TUnfold*) G__getstructoffset())->GetLcurveX());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_391_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TUnfold*) G__getstructoffset())->GetLcurveY());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_391_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TUnfold*) G__getstructoffset())->GetNdf());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_391_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TUnfold*) G__getstructoffset())->GetNpar());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_391_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TUnfold::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_391_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TUnfold::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_391_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TUnfold::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_391_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TUnfold::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_391_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TUnfold*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_391_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TUnfold::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_391_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TUnfold::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_391_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TUnfold::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_391_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TUnfold::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Hist_391_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TUnfold* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TUnfold(*(TUnfold*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TUnfold));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TUnfold G__TTUnfold;
static int G__G__Hist_391_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TUnfold*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TUnfold*) (soff+(sizeof(TUnfold)*i)))->~G__TTUnfold();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TUnfold*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TUnfold*) (soff))->~G__TTUnfold();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Hist_391_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TUnfold* dest = (TUnfold*) G__getstructoffset();
   *dest = *(TUnfold*) libp->para[0].ref;
   const TUnfold& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TUnfoldSys */
static int G__G__Hist_396_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TUnfoldSys* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TUnfoldSys(
(TH2*) G__int(libp->para[0]), (TUnfold::EHistMap) G__int(libp->para[1])
, (TUnfold::ERegMode) G__int(libp->para[2]), (TUnfold::EConstraint) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TUnfoldSys(
(TH2*) G__int(libp->para[0]), (TUnfold::EHistMap) G__int(libp->para[1])
, (TUnfold::ERegMode) G__int(libp->para[2]), (TUnfold::EConstraint) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TUnfoldSys(
(TH2*) G__int(libp->para[0]), (TUnfold::EHistMap) G__int(libp->para[1])
, (TUnfold::ERegMode) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TUnfoldSys(
(TH2*) G__int(libp->para[0]), (TUnfold::EHistMap) G__int(libp->para[1])
, (TUnfold::ERegMode) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TUnfoldSys((TH2*) G__int(libp->para[0]), (TUnfold::EHistMap) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TUnfoldSys((TH2*) G__int(libp->para[0]), (TUnfold::EHistMap) G__int(libp->para[1]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TUnfoldSys));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_396_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TUnfoldSys*) G__getstructoffset())->AddSysError((TH2*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TUnfold::EHistMap) G__int(libp->para[2]), (TUnfoldSys::ESysErrMode) G__int(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_396_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TUnfoldSys*) G__getstructoffset())->GetDeltaSysSource((TH1*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const Int_t*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TUnfoldSys*) G__getstructoffset())->GetDeltaSysSource((TH1*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_396_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TUnfoldSys*) G__getstructoffset())->SubtractBackground((TH1*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TUnfoldSys*) G__getstructoffset())->SubtractBackground((TH1*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TUnfoldSys*) G__getstructoffset())->SubtractBackground((TH1*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_396_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TUnfoldSys*) G__getstructoffset())->GetDeltaSysBackgroundScale((TH1*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const Int_t*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TUnfoldSys*) G__getstructoffset())->GetDeltaSysBackgroundScale((TH1*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_396_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TUnfoldSys*) G__getstructoffset())->SetTauError((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_396_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TUnfoldSys*) G__getstructoffset())->GetDeltaSysTau((TH1*) G__int(libp->para[0]), (const Int_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TUnfoldSys*) G__getstructoffset())->GetDeltaSysTau((TH1*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_396_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TUnfoldSys*) G__getstructoffset())->GetEmatrixSysUncorr((TH2*) G__int(libp->para[0]), (const Int_t*) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TUnfoldSys*) G__getstructoffset())->GetEmatrixSysUncorr((TH2*) G__int(libp->para[0]), (const Int_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TUnfoldSys*) G__getstructoffset())->GetEmatrixSysUncorr((TH2*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_396_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TUnfoldSys*) G__getstructoffset())->GetEmatrixSysSource((TH2*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const Int_t*) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TUnfoldSys*) G__getstructoffset())->GetEmatrixSysSource((TH2*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const Int_t*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TUnfoldSys*) G__getstructoffset())->GetEmatrixSysSource((TH2*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_396_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TUnfoldSys*) G__getstructoffset())->GetEmatrixSysBackgroundUncorr((TH2*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const Int_t*) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TUnfoldSys*) G__getstructoffset())->GetEmatrixSysBackgroundUncorr((TH2*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const Int_t*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TUnfoldSys*) G__getstructoffset())->GetEmatrixSysBackgroundUncorr((TH2*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_396_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TUnfoldSys*) G__getstructoffset())->GetEmatrixSysBackgroundScale((TH2*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const Int_t*) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TUnfoldSys*) G__getstructoffset())->GetEmatrixSysBackgroundScale((TH2*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const Int_t*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TUnfoldSys*) G__getstructoffset())->GetEmatrixSysBackgroundScale((TH2*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_396_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TUnfoldSys*) G__getstructoffset())->GetEmatrixSysTau((TH2*) G__int(libp->para[0]), (const Int_t*) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TUnfoldSys*) G__getstructoffset())->GetEmatrixSysTau((TH2*) G__int(libp->para[0]), (const Int_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TUnfoldSys*) G__getstructoffset())->GetEmatrixSysTau((TH2*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_396_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TUnfoldSys*) G__getstructoffset())->GetEmatrixInput((TH2*) G__int(libp->para[0]), (const Int_t*) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TUnfoldSys*) G__getstructoffset())->GetEmatrixInput((TH2*) G__int(libp->para[0]), (const Int_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TUnfoldSys*) G__getstructoffset())->GetEmatrixInput((TH2*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_396_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TUnfoldSys*) G__getstructoffset())->GetEmatrixTotal((TH2*) G__int(libp->para[0]), (const Int_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TUnfoldSys*) G__getstructoffset())->GetEmatrixTotal((TH2*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_396_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TUnfoldSys*) G__getstructoffset())->GetChi2Sys());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_396_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TUnfoldSys::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_396_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TUnfoldSys::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_396_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TUnfoldSys::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_396_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TUnfoldSys::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_396_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TUnfoldSys*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_396_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TUnfoldSys::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_396_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TUnfoldSys::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_396_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TUnfoldSys::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_396_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TUnfoldSys::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Hist_396_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TUnfoldSys* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TUnfoldSys(*(TUnfoldSys*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_TUnfoldSys));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TUnfoldSys G__TTUnfoldSys;
static int G__G__Hist_396_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TUnfoldSys*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TUnfoldSys*) (soff+(sizeof(TUnfoldSys)*i)))->~G__TTUnfoldSys();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TUnfoldSys*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TUnfoldSys*) (soff))->~G__TTUnfoldSys();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Hist_396_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TUnfoldSys* dest = (TUnfoldSys*) G__getstructoffset();
   *dest = *(TUnfoldSys*) libp->para[0].ref;
   const TUnfoldSys& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TVirtualGraphPainter */
static int G__G__Hist_398_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TVirtualGraphPainter*) G__getstructoffset())->DistancetoPrimitiveHelper((TGraph*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_398_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualGraphPainter*) G__getstructoffset())->DrawPanelHelper((TGraph*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_398_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualGraphPainter*) G__getstructoffset())->ExecuteEventHelper((TGraph*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_398_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TVirtualGraphPainter*) G__getstructoffset())->GetObjectInfoHelper((TGraph*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_398_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualGraphPainter*) G__getstructoffset())->PaintHelper((TGraph*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_398_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualGraphPainter*) G__getstructoffset())->PaintGraph((TGraph*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Option_t*) G__int(libp->para[4]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_398_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualGraphPainter*) G__getstructoffset())->PaintGrapHist((TGraph*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Option_t*) G__int(libp->para[4]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_398_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualGraphPainter*) G__getstructoffset())->PaintStats((TGraph*) G__int(libp->para[0]), (TF1*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_398_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TVirtualGraphPainter::GetPainter());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_398_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TVirtualGraphPainter::SetPainter((TVirtualGraphPainter*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_398_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TVirtualGraphPainter::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_398_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TVirtualGraphPainter::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_398_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TVirtualGraphPainter::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_398_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TVirtualGraphPainter::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_398_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualGraphPainter*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_398_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TVirtualGraphPainter::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_398_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TVirtualGraphPainter::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_398_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TVirtualGraphPainter::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_398_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TVirtualGraphPainter::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TVirtualGraphPainter G__TTVirtualGraphPainter;
static int G__G__Hist_398_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TVirtualGraphPainter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TVirtualGraphPainter*) (soff+(sizeof(TVirtualGraphPainter)*i)))->~G__TTVirtualGraphPainter();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TVirtualGraphPainter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TVirtualGraphPainter*) (soff))->~G__TTVirtualGraphPainter();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Hist_398_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TVirtualGraphPainter* dest = (TVirtualGraphPainter*) G__getstructoffset();
   *dest = *(TVirtualGraphPainter*) libp->para[0].ref;
   const TVirtualGraphPainter& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* ROOT::Math::WrappedMultiTF1 */
static int G__G__Hist_401_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Math::WrappedMultiTF1* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Math::WrappedMultiTF1(*(TF1*) libp->para[0].ref, (unsigned int) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) ROOT::Math::WrappedMultiTF1(*(TF1*) libp->para[0].ref, (unsigned int) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Math::WrappedMultiTF1(*(TF1*) libp->para[0].ref);
     } else {
       p = new((void*) gvp) ROOT::Math::WrappedMultiTF1(*(TF1*) libp->para[0].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_ROOTcLcLMathcLcLWrappedMultiTF1));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_401_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Math::WrappedMultiTF1* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new ROOT::Math::WrappedMultiTF1(*(ROOT::Math::WrappedMultiTF1*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) ROOT::Math::WrappedMultiTF1(*(ROOT::Math::WrappedMultiTF1*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_ROOTcLcLMathcLcLWrappedMultiTF1));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_401_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::WrappedMultiTF1& obj = ((ROOT::Math::WrappedMultiTF1*) G__getstructoffset())->operator=(*(ROOT::Math::WrappedMultiTF1*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_401_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ROOT::Math::WrappedMultiTF1::SetDerivPrecision((double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_401_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ROOT::Math::WrappedMultiTF1::GetDerivPrecision());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef ROOT::Math::WrappedMultiTF1 G__TROOTcLcLMathcLcLWrappedMultiTF1;
static int G__G__Hist_401_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (ROOT::Math::WrappedMultiTF1*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((ROOT::Math::WrappedMultiTF1*) (soff+(sizeof(ROOT::Math::WrappedMultiTF1)*i)))->~G__TROOTcLcLMathcLcLWrappedMultiTF1();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (ROOT::Math::WrappedMultiTF1*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((ROOT::Math::WrappedMultiTF1*) (soff))->~G__TROOTcLcLMathcLcLWrappedMultiTF1();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* ROOT::Math::WrappedTF1 */
static int G__G__Hist_402_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Math::WrappedTF1* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new ROOT::Math::WrappedTF1(*(TF1*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) ROOT::Math::WrappedTF1(*(TF1*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_ROOTcLcLMathcLcLWrappedTF1));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_402_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Math::WrappedTF1* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new ROOT::Math::WrappedTF1(*(ROOT::Math::WrappedTF1*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) ROOT::Math::WrappedTF1(*(ROOT::Math::WrappedTF1*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__HistLN_ROOTcLcLMathcLcLWrappedTF1));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_402_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::WrappedTF1& obj = ((ROOT::Math::WrappedTF1*) G__getstructoffset())->operator=(*(ROOT::Math::WrappedTF1*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_402_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ROOT::Math::WrappedTF1::SetDerivPrecision((double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist_402_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ROOT::Math::WrappedTF1::GetDerivPrecision());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef ROOT::Math::WrappedTF1 G__TROOTcLcLMathcLcLWrappedTF1;
static int G__G__Hist_402_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[] (ROOT::Math::WrappedTF1*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((ROOT::Math::WrappedTF1*) (soff+(sizeof(ROOT::Math::WrappedTF1)*i)))->~G__TROOTcLcLMathcLcLWrappedTF1();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (ROOT::Math::WrappedTF1*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((ROOT::Math::WrappedTF1*) (soff))->~G__TROOTcLcLMathcLcLWrappedTF1();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* Setting up global function */
static int G__G__Hist__0_858(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH1C* pobj;
         TH1C xobj = operator*((Double_t) G__double(libp->para[0]), *(TH1C*) libp->para[1].ref);
         pobj = new TH1C(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_859(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH1C* pobj;
         TH1C xobj = operator*(*(TH1C*) libp->para[0].ref, (Double_t) G__double(libp->para[1]));
         pobj = new TH1C(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_860(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH1C* pobj;
         TH1C xobj = operator+(*(TH1C*) libp->para[0].ref, *(TH1C*) libp->para[1].ref);
         pobj = new TH1C(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_861(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH1C* pobj;
         TH1C xobj = operator-(*(TH1C*) libp->para[0].ref, *(TH1C*) libp->para[1].ref);
         pobj = new TH1C(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_862(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH1C* pobj;
         TH1C xobj = operator*(*(TH1C*) libp->para[0].ref, *(TH1C*) libp->para[1].ref);
         pobj = new TH1C(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_863(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH1C* pobj;
         TH1C xobj = operator/(*(TH1C*) libp->para[0].ref, *(TH1C*) libp->para[1].ref);
         pobj = new TH1C(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_864(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH1S* pobj;
         TH1S xobj = operator*((Double_t) G__double(libp->para[0]), *(TH1S*) libp->para[1].ref);
         pobj = new TH1S(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_865(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH1S* pobj;
         TH1S xobj = operator*(*(TH1S*) libp->para[0].ref, (Double_t) G__double(libp->para[1]));
         pobj = new TH1S(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_866(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH1S* pobj;
         TH1S xobj = operator+(*(TH1S*) libp->para[0].ref, *(TH1S*) libp->para[1].ref);
         pobj = new TH1S(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_867(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH1S* pobj;
         TH1S xobj = operator-(*(TH1S*) libp->para[0].ref, *(TH1S*) libp->para[1].ref);
         pobj = new TH1S(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_868(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH1S* pobj;
         TH1S xobj = operator*(*(TH1S*) libp->para[0].ref, *(TH1S*) libp->para[1].ref);
         pobj = new TH1S(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_869(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH1S* pobj;
         TH1S xobj = operator/(*(TH1S*) libp->para[0].ref, *(TH1S*) libp->para[1].ref);
         pobj = new TH1S(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_870(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH1I* pobj;
         TH1I xobj = operator*((Double_t) G__double(libp->para[0]), *(TH1I*) libp->para[1].ref);
         pobj = new TH1I(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_871(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH1I* pobj;
         TH1I xobj = operator*(*(TH1I*) libp->para[0].ref, (Double_t) G__double(libp->para[1]));
         pobj = new TH1I(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_872(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH1I* pobj;
         TH1I xobj = operator+(*(TH1I*) libp->para[0].ref, *(TH1I*) libp->para[1].ref);
         pobj = new TH1I(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_873(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH1I* pobj;
         TH1I xobj = operator-(*(TH1I*) libp->para[0].ref, *(TH1I*) libp->para[1].ref);
         pobj = new TH1I(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_874(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH1I* pobj;
         TH1I xobj = operator*(*(TH1I*) libp->para[0].ref, *(TH1I*) libp->para[1].ref);
         pobj = new TH1I(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_875(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH1I* pobj;
         TH1I xobj = operator/(*(TH1I*) libp->para[0].ref, *(TH1I*) libp->para[1].ref);
         pobj = new TH1I(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_876(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH1F* pobj;
         TH1F xobj = operator*((Double_t) G__double(libp->para[0]), *(TH1F*) libp->para[1].ref);
         pobj = new TH1F(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_877(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH1F* pobj;
         TH1F xobj = operator*(*(TH1F*) libp->para[0].ref, (Double_t) G__double(libp->para[1]));
         pobj = new TH1F(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_878(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH1F* pobj;
         TH1F xobj = operator+(*(TH1F*) libp->para[0].ref, *(TH1F*) libp->para[1].ref);
         pobj = new TH1F(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_879(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH1F* pobj;
         TH1F xobj = operator-(*(TH1F*) libp->para[0].ref, *(TH1F*) libp->para[1].ref);
         pobj = new TH1F(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_880(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH1F* pobj;
         TH1F xobj = operator*(*(TH1F*) libp->para[0].ref, *(TH1F*) libp->para[1].ref);
         pobj = new TH1F(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_881(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH1F* pobj;
         TH1F xobj = operator/(*(TH1F*) libp->para[0].ref, *(TH1F*) libp->para[1].ref);
         pobj = new TH1F(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_882(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH1D* pobj;
         TH1D xobj = operator*((Double_t) G__double(libp->para[0]), *(TH1D*) libp->para[1].ref);
         pobj = new TH1D(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_883(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH1D* pobj;
         TH1D xobj = operator*(*(TH1D*) libp->para[0].ref, (Double_t) G__double(libp->para[1]));
         pobj = new TH1D(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_884(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH1D* pobj;
         TH1D xobj = operator+(*(TH1D*) libp->para[0].ref, *(TH1D*) libp->para[1].ref);
         pobj = new TH1D(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_885(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH1D* pobj;
         TH1D xobj = operator-(*(TH1D*) libp->para[0].ref, *(TH1D*) libp->para[1].ref);
         pobj = new TH1D(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_886(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH1D* pobj;
         TH1D xobj = operator*(*(TH1D*) libp->para[0].ref, *(TH1D*) libp->para[1].ref);
         pobj = new TH1D(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_887(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH1D* pobj;
         TH1D xobj = operator/(*(TH1D*) libp->para[0].ref, *(TH1D*) libp->para[1].ref);
         pobj = new TH1D(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_888(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) R__H((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_889(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) R__H((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_890(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH2C* pobj;
         TH2C xobj = operator*((Float_t) G__double(libp->para[0]), *(TH2C*) libp->para[1].ref);
         pobj = new TH2C(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_891(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH2C* pobj;
         TH2C xobj = operator*(*(TH2C*) libp->para[0].ref, (Float_t) G__double(libp->para[1]));
         pobj = new TH2C(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_892(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH2C* pobj;
         TH2C xobj = operator+(*(TH2C*) libp->para[0].ref, *(TH2C*) libp->para[1].ref);
         pobj = new TH2C(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_893(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH2C* pobj;
         TH2C xobj = operator-(*(TH2C*) libp->para[0].ref, *(TH2C*) libp->para[1].ref);
         pobj = new TH2C(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_894(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH2C* pobj;
         TH2C xobj = operator*(*(TH2C*) libp->para[0].ref, *(TH2C*) libp->para[1].ref);
         pobj = new TH2C(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_895(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH2C* pobj;
         TH2C xobj = operator/(*(TH2C*) libp->para[0].ref, *(TH2C*) libp->para[1].ref);
         pobj = new TH2C(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_896(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH2S* pobj;
         TH2S xobj = operator*((Float_t) G__double(libp->para[0]), *(TH2S*) libp->para[1].ref);
         pobj = new TH2S(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_897(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH2S* pobj;
         TH2S xobj = operator*(*(TH2S*) libp->para[0].ref, (Float_t) G__double(libp->para[1]));
         pobj = new TH2S(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_898(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH2S* pobj;
         TH2S xobj = operator+(*(TH2S*) libp->para[0].ref, *(TH2S*) libp->para[1].ref);
         pobj = new TH2S(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_899(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH2S* pobj;
         TH2S xobj = operator-(*(TH2S*) libp->para[0].ref, *(TH2S*) libp->para[1].ref);
         pobj = new TH2S(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_900(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH2S* pobj;
         TH2S xobj = operator*(*(TH2S*) libp->para[0].ref, *(TH2S*) libp->para[1].ref);
         pobj = new TH2S(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_901(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH2S* pobj;
         TH2S xobj = operator/(*(TH2S*) libp->para[0].ref, *(TH2S*) libp->para[1].ref);
         pobj = new TH2S(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_902(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH2I* pobj;
         TH2I xobj = operator*((Float_t) G__double(libp->para[0]), *(TH2I*) libp->para[1].ref);
         pobj = new TH2I(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_903(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH2I* pobj;
         TH2I xobj = operator*(*(TH2I*) libp->para[0].ref, (Float_t) G__double(libp->para[1]));
         pobj = new TH2I(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_904(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH2I* pobj;
         TH2I xobj = operator+(*(TH2I*) libp->para[0].ref, *(TH2I*) libp->para[1].ref);
         pobj = new TH2I(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_905(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH2I* pobj;
         TH2I xobj = operator-(*(TH2I*) libp->para[0].ref, *(TH2I*) libp->para[1].ref);
         pobj = new TH2I(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_906(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH2I* pobj;
         TH2I xobj = operator*(*(TH2I*) libp->para[0].ref, *(TH2I*) libp->para[1].ref);
         pobj = new TH2I(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_907(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH2I* pobj;
         TH2I xobj = operator/(*(TH2I*) libp->para[0].ref, *(TH2I*) libp->para[1].ref);
         pobj = new TH2I(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_908(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH2F* pobj;
         TH2F xobj = operator*((Float_t) G__double(libp->para[0]), *(TH2F*) libp->para[1].ref);
         pobj = new TH2F(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_909(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH2F* pobj;
         TH2F xobj = operator*(*(TH2F*) libp->para[0].ref, (Float_t) G__double(libp->para[1]));
         pobj = new TH2F(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_910(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH2F* pobj;
         TH2F xobj = operator+(*(TH2F*) libp->para[0].ref, *(TH2F*) libp->para[1].ref);
         pobj = new TH2F(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_911(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH2F* pobj;
         TH2F xobj = operator-(*(TH2F*) libp->para[0].ref, *(TH2F*) libp->para[1].ref);
         pobj = new TH2F(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_912(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH2F* pobj;
         TH2F xobj = operator*(*(TH2F*) libp->para[0].ref, *(TH2F*) libp->para[1].ref);
         pobj = new TH2F(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_913(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH2F* pobj;
         TH2F xobj = operator/(*(TH2F*) libp->para[0].ref, *(TH2F*) libp->para[1].ref);
         pobj = new TH2F(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_914(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH2D* pobj;
         TH2D xobj = operator*((Float_t) G__double(libp->para[0]), *(TH2D*) libp->para[1].ref);
         pobj = new TH2D(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_915(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH2D* pobj;
         TH2D xobj = operator*(*(TH2D*) libp->para[0].ref, (Float_t) G__double(libp->para[1]));
         pobj = new TH2D(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_916(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH2D* pobj;
         TH2D xobj = operator+(*(TH2D*) libp->para[0].ref, *(TH2D*) libp->para[1].ref);
         pobj = new TH2D(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_917(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH2D* pobj;
         TH2D xobj = operator-(*(TH2D*) libp->para[0].ref, *(TH2D*) libp->para[1].ref);
         pobj = new TH2D(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_918(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH2D* pobj;
         TH2D xobj = operator*(*(TH2D*) libp->para[0].ref, *(TH2D*) libp->para[1].ref);
         pobj = new TH2D(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_919(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH2D* pobj;
         TH2D xobj = operator/(*(TH2D*) libp->para[0].ref, *(TH2D*) libp->para[1].ref);
         pobj = new TH2D(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_920(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH3C* pobj;
         TH3C xobj = operator*((Float_t) G__double(libp->para[0]), *(TH3C*) libp->para[1].ref);
         pobj = new TH3C(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_921(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH3C* pobj;
         TH3C xobj = operator*(*(TH3C*) libp->para[0].ref, (Float_t) G__double(libp->para[1]));
         pobj = new TH3C(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_922(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH3C* pobj;
         TH3C xobj = operator+(*(TH3C*) libp->para[0].ref, *(TH3C*) libp->para[1].ref);
         pobj = new TH3C(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_923(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH3C* pobj;
         TH3C xobj = operator-(*(TH3C*) libp->para[0].ref, *(TH3C*) libp->para[1].ref);
         pobj = new TH3C(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_924(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH3C* pobj;
         TH3C xobj = operator*(*(TH3C*) libp->para[0].ref, *(TH3C*) libp->para[1].ref);
         pobj = new TH3C(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_925(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH3C* pobj;
         TH3C xobj = operator/(*(TH3C*) libp->para[0].ref, *(TH3C*) libp->para[1].ref);
         pobj = new TH3C(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_926(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH3S* pobj;
         TH3S xobj = operator*((Float_t) G__double(libp->para[0]), *(TH3S*) libp->para[1].ref);
         pobj = new TH3S(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_927(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH3S* pobj;
         TH3S xobj = operator*(*(TH3S*) libp->para[0].ref, (Float_t) G__double(libp->para[1]));
         pobj = new TH3S(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_928(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH3S* pobj;
         TH3S xobj = operator+(*(TH3S*) libp->para[0].ref, *(TH3S*) libp->para[1].ref);
         pobj = new TH3S(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_929(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH3S* pobj;
         TH3S xobj = operator-(*(TH3S*) libp->para[0].ref, *(TH3S*) libp->para[1].ref);
         pobj = new TH3S(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_930(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH3S* pobj;
         TH3S xobj = operator*(*(TH3S*) libp->para[0].ref, *(TH3S*) libp->para[1].ref);
         pobj = new TH3S(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_931(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH3S* pobj;
         TH3S xobj = operator/(*(TH3S*) libp->para[0].ref, *(TH3S*) libp->para[1].ref);
         pobj = new TH3S(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_932(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH3I* pobj;
         TH3I xobj = operator*((Float_t) G__double(libp->para[0]), *(TH3I*) libp->para[1].ref);
         pobj = new TH3I(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_933(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH3I* pobj;
         TH3I xobj = operator*(*(TH3I*) libp->para[0].ref, (Float_t) G__double(libp->para[1]));
         pobj = new TH3I(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_934(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH3I* pobj;
         TH3I xobj = operator+(*(TH3I*) libp->para[0].ref, *(TH3I*) libp->para[1].ref);
         pobj = new TH3I(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_935(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH3I* pobj;
         TH3I xobj = operator-(*(TH3I*) libp->para[0].ref, *(TH3I*) libp->para[1].ref);
         pobj = new TH3I(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_936(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH3I* pobj;
         TH3I xobj = operator*(*(TH3I*) libp->para[0].ref, *(TH3I*) libp->para[1].ref);
         pobj = new TH3I(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_937(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH3I* pobj;
         TH3I xobj = operator/(*(TH3I*) libp->para[0].ref, *(TH3I*) libp->para[1].ref);
         pobj = new TH3I(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_938(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH3F* pobj;
         TH3F xobj = operator*((Float_t) G__double(libp->para[0]), *(TH3F*) libp->para[1].ref);
         pobj = new TH3F(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_939(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH3F* pobj;
         TH3F xobj = operator*(*(TH3F*) libp->para[0].ref, (Float_t) G__double(libp->para[1]));
         pobj = new TH3F(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_940(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH3F* pobj;
         TH3F xobj = operator+(*(TH3F*) libp->para[0].ref, *(TH3F*) libp->para[1].ref);
         pobj = new TH3F(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_941(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH3F* pobj;
         TH3F xobj = operator-(*(TH3F*) libp->para[0].ref, *(TH3F*) libp->para[1].ref);
         pobj = new TH3F(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_942(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH3F* pobj;
         TH3F xobj = operator*(*(TH3F*) libp->para[0].ref, *(TH3F*) libp->para[1].ref);
         pobj = new TH3F(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_943(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH3F* pobj;
         TH3F xobj = operator/(*(TH3F*) libp->para[0].ref, *(TH3F*) libp->para[1].ref);
         pobj = new TH3F(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_944(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH3D* pobj;
         TH3D xobj = operator*((Float_t) G__double(libp->para[0]), *(TH3D*) libp->para[1].ref);
         pobj = new TH3D(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_945(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH3D* pobj;
         TH3D xobj = operator*(*(TH3D*) libp->para[0].ref, (Float_t) G__double(libp->para[1]));
         pobj = new TH3D(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_946(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH3D* pobj;
         TH3D xobj = operator+(*(TH3D*) libp->para[0].ref, *(TH3D*) libp->para[1].ref);
         pobj = new TH3D(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_947(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH3D* pobj;
         TH3D xobj = operator-(*(TH3D*) libp->para[0].ref, *(TH3D*) libp->para[1].ref);
         pobj = new TH3D(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_948(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH3D* pobj;
         TH3D xobj = operator*(*(TH3D*) libp->para[0].ref, *(TH3D*) libp->para[1].ref);
         pobj = new TH3D(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Hist__0_949(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TH3D* pobj;
         TH3D xobj = operator/(*(TH3D*) libp->para[0].ref, *(TH3D*) libp->para[1].ref);
         pobj = new TH3D(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}


/*********************************************************
* Member function Stub
*********************************************************/

/* Foption_t */

/* TH1 */

/* THnSparse */

/* TF1 */

/* TF2 */

/* TGraph */

/* TGraphErrors */

/* TGraph2D */

/* TMultiGraph */

/* TFitResult */

/* TFitResultPtr */

/* ROOT::Fit */

/* TAxis */

/* TBackCompFitter */

/* TBinomialEfficiencyFitter */

/* TConfidenceLevel */

/* TGraphAsymmErrors */

/* TH2 */

/* TEfficiency */

/* TFormulaPrimitive */

/* TFormula */

/* TF12 */

/* TF3 */

/* TFractionFitter */

/* TVirtualHistPainter */

/* TH2D */

/* TGraph2DErrors */

/* TH1F */

/* TSpline */

/* TGraphBentErrors */

/* TGraphDelaunay */

/* TGraphSmooth */

/* TGraphTime */

/* TH1D */

/* TH1C */

/* TH1S */

/* TH1I */

/* TH1K */

/* TProfile */

/* TH2C */

/* TH2S */

/* TH2I */

/* TH2F */

/* TH2PolyBin */

/* TH2Poly */

/* TProfile2D */

/* TH3 */

/* TH3C */

/* TH3S */

/* TH3I */

/* TH3F */

/* TH3D */

/* THLimitsFinder */

/* THnSparseArrayChunk */

/* THnSparseT<TArrayD> */

/* THnSparseT<TArrayF> */

/* THnSparseT<TArrayL> */

/* THnSparseT<TArrayI> */

/* THnSparseT<TArrayS> */

/* THnSparseT<TArrayC> */

/* THStack */

/* TKDE */

/* TLimitDataSource */

/* TLimit */

/* TMultiDimFit */

/* TPolyMarker */

/* TPrincipal */

/* TProfile3D */

/* TSplinePoly */

/* TSplinePoly3 */

/* TSplinePoly5 */

/* TSpline3 */

/* TSpline5 */

/* TSVDUnfold */

/* TUnfold */

/* TUnfoldSys */

/* TVirtualGraphPainter */

/* ROOT::Math::WrappedMultiTF1 */

/* ROOT::Math::WrappedTF1 */

/*********************************************************
* Global function Stub
*********************************************************/

/*********************************************************
* Get size of pointer to member function
*********************************************************/
class G__Sizep2memfuncG__Hist {
 public:
  G__Sizep2memfuncG__Hist(): p(&G__Sizep2memfuncG__Hist::sizep2memfunc) {}
    size_t sizep2memfunc() { return(sizeof(p)); }
  private:
    size_t (G__Sizep2memfuncG__Hist::*p)();
};

size_t G__get_sizep2memfuncG__Hist()
{
  G__Sizep2memfuncG__Hist a;
  G__setsizep2memfunc((int)a.sizep2memfunc());
  return((size_t)a.sizep2memfunc());
}


/*********************************************************
* virtual base class offset calculation interface
*********************************************************/

   /* Setting up class inheritance */
static long G__2vbo_ROOTcLcLMathcLcLWrappedMultiTF1_ROOTcLcLMathcLcLIBaseFunctionMultiDim_2(long pobject) {
  ROOT::Math::WrappedMultiTF1 *G__Lderived=(ROOT::Math::WrappedMultiTF1*)pobject;
  ROOT::Math::IBaseFunctionMultiDim *G__Lbase=G__Lderived;
  return((long)G__Lbase-(long)G__Lderived);
}

static long G__2vbo_ROOTcLcLMathcLcLWrappedTF1_ROOTcLcLMathcLcLIBaseFunctionOneDim_2(long pobject) {
  ROOT::Math::WrappedTF1 *G__Lderived=(ROOT::Math::WrappedTF1*)pobject;
  ROOT::Math::IBaseFunctionOneDim *G__Lbase=G__Lderived;
  return((long)G__Lbase-(long)G__Lderived);
}


/*********************************************************
* Inheritance information setup/
*********************************************************/
extern "C" void G__cpp_setup_inheritanceG__Hist() {

   /* Setting up class inheritance */
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_TH1))) {
     TH1 *G__Lderived;
     G__Lderived=(TH1*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH1),G__get_linked_tagnum(&G__G__HistLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH1),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH1),G__get_linked_tagnum(&G__G__HistLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH1),G__get_linked_tagnum(&G__G__HistLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH1),G__get_linked_tagnum(&G__G__HistLN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_THnSparse))) {
     THnSparse *G__Lderived;
     G__Lderived=(THnSparse*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_THnSparse),G__get_linked_tagnum(&G__G__HistLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_THnSparse),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_TF1))) {
     TF1 *G__Lderived;
     G__Lderived=(TF1*)0x1000;
     {
       TFormula *G__Lpbase=(TFormula*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TF1),G__get_linked_tagnum(&G__G__HistLN_TFormula),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TF1),G__get_linked_tagnum(&G__G__HistLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TF1),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TF1),G__get_linked_tagnum(&G__G__HistLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TF1),G__get_linked_tagnum(&G__G__HistLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TF1),G__get_linked_tagnum(&G__G__HistLN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_TF2))) {
     TF2 *G__Lderived;
     G__Lderived=(TF2*)0x1000;
     {
       TF1 *G__Lpbase=(TF1*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TF2),G__get_linked_tagnum(&G__G__HistLN_TF1),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TFormula *G__Lpbase=(TFormula*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TF2),G__get_linked_tagnum(&G__G__HistLN_TFormula),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TF2),G__get_linked_tagnum(&G__G__HistLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TF2),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TF2),G__get_linked_tagnum(&G__G__HistLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TF2),G__get_linked_tagnum(&G__G__HistLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TF2),G__get_linked_tagnum(&G__G__HistLN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_TGraph))) {
     TGraph *G__Lderived;
     G__Lderived=(TGraph*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TGraph),G__get_linked_tagnum(&G__G__HistLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TGraph),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TGraph),G__get_linked_tagnum(&G__G__HistLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TGraph),G__get_linked_tagnum(&G__G__HistLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TGraph),G__get_linked_tagnum(&G__G__HistLN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_TGraphErrors))) {
     TGraphErrors *G__Lderived;
     G__Lderived=(TGraphErrors*)0x1000;
     {
       TGraph *G__Lpbase=(TGraph*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TGraphErrors),G__get_linked_tagnum(&G__G__HistLN_TGraph),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TGraphErrors),G__get_linked_tagnum(&G__G__HistLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TGraphErrors),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TGraphErrors),G__get_linked_tagnum(&G__G__HistLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TGraphErrors),G__get_linked_tagnum(&G__G__HistLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TGraphErrors),G__get_linked_tagnum(&G__G__HistLN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_TGraph2D))) {
     TGraph2D *G__Lderived;
     G__Lderived=(TGraph2D*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TGraph2D),G__get_linked_tagnum(&G__G__HistLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TGraph2D),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TGraph2D),G__get_linked_tagnum(&G__G__HistLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TGraph2D),G__get_linked_tagnum(&G__G__HistLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TGraph2D),G__get_linked_tagnum(&G__G__HistLN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_TMultiGraph))) {
     TMultiGraph *G__Lderived;
     G__Lderived=(TMultiGraph*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TMultiGraph),G__get_linked_tagnum(&G__G__HistLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TMultiGraph),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_TFitResult))) {
     TFitResult *G__Lderived;
     G__Lderived=(TFitResult*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TFitResult),G__get_linked_tagnum(&G__G__HistLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TFitResult),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       ROOT::Fit::FitResult *G__Lpbase=(ROOT::Fit::FitResult*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TFitResult),G__get_linked_tagnum(&G__G__HistLN_ROOTcLcLFitcLcLFitResult),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_TAxis))) {
     TAxis *G__Lderived;
     G__Lderived=(TAxis*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TAxis),G__get_linked_tagnum(&G__G__HistLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TAxis),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttAxis *G__Lpbase=(TAttAxis*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TAxis),G__get_linked_tagnum(&G__G__HistLN_TAttAxis),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_TBackCompFitter))) {
     TBackCompFitter *G__Lderived;
     G__Lderived=(TBackCompFitter*)0x1000;
     {
       TVirtualFitter *G__Lpbase=(TVirtualFitter*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TBackCompFitter),G__get_linked_tagnum(&G__G__HistLN_TVirtualFitter),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TBackCompFitter),G__get_linked_tagnum(&G__G__HistLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TBackCompFitter),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_TBinomialEfficiencyFitter))) {
     TBinomialEfficiencyFitter *G__Lderived;
     G__Lderived=(TBinomialEfficiencyFitter*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TBinomialEfficiencyFitter),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_TConfidenceLevel))) {
     TConfidenceLevel *G__Lderived;
     G__Lderived=(TConfidenceLevel*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TConfidenceLevel),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_TGraphAsymmErrors))) {
     TGraphAsymmErrors *G__Lderived;
     G__Lderived=(TGraphAsymmErrors*)0x1000;
     {
       TGraph *G__Lpbase=(TGraph*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TGraphAsymmErrors),G__get_linked_tagnum(&G__G__HistLN_TGraph),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TGraphAsymmErrors),G__get_linked_tagnum(&G__G__HistLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TGraphAsymmErrors),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TGraphAsymmErrors),G__get_linked_tagnum(&G__G__HistLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TGraphAsymmErrors),G__get_linked_tagnum(&G__G__HistLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TGraphAsymmErrors),G__get_linked_tagnum(&G__G__HistLN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_TH2))) {
     TH2 *G__Lderived;
     G__Lderived=(TH2*)0x1000;
     {
       TH1 *G__Lpbase=(TH1*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH2),G__get_linked_tagnum(&G__G__HistLN_TH1),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH2),G__get_linked_tagnum(&G__G__HistLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH2),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH2),G__get_linked_tagnum(&G__G__HistLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH2),G__get_linked_tagnum(&G__G__HistLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH2),G__get_linked_tagnum(&G__G__HistLN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_TEfficiency))) {
     TEfficiency *G__Lderived;
     G__Lderived=(TEfficiency*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TEfficiency),G__get_linked_tagnum(&G__G__HistLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TEfficiency),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TEfficiency),G__get_linked_tagnum(&G__G__HistLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TEfficiency),G__get_linked_tagnum(&G__G__HistLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TEfficiency),G__get_linked_tagnum(&G__G__HistLN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_TFormulaPrimitive))) {
     TFormulaPrimitive *G__Lderived;
     G__Lderived=(TFormulaPrimitive*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TFormulaPrimitive),G__get_linked_tagnum(&G__G__HistLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TFormulaPrimitive),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_TFormula))) {
     TFormula *G__Lderived;
     G__Lderived=(TFormula*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TFormula),G__get_linked_tagnum(&G__G__HistLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TFormula),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_TF12))) {
     TF12 *G__Lderived;
     G__Lderived=(TF12*)0x1000;
     {
       TF1 *G__Lpbase=(TF1*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TF12),G__get_linked_tagnum(&G__G__HistLN_TF1),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TFormula *G__Lpbase=(TFormula*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TF12),G__get_linked_tagnum(&G__G__HistLN_TFormula),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TF12),G__get_linked_tagnum(&G__G__HistLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TF12),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TF12),G__get_linked_tagnum(&G__G__HistLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TF12),G__get_linked_tagnum(&G__G__HistLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TF12),G__get_linked_tagnum(&G__G__HistLN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_TF3))) {
     TF3 *G__Lderived;
     G__Lderived=(TF3*)0x1000;
     {
       TF2 *G__Lpbase=(TF2*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TF3),G__get_linked_tagnum(&G__G__HistLN_TF2),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TF1 *G__Lpbase=(TF1*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TF3),G__get_linked_tagnum(&G__G__HistLN_TF1),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TFormula *G__Lpbase=(TFormula*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TF3),G__get_linked_tagnum(&G__G__HistLN_TFormula),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TF3),G__get_linked_tagnum(&G__G__HistLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TF3),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TF3),G__get_linked_tagnum(&G__G__HistLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TF3),G__get_linked_tagnum(&G__G__HistLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TF3),G__get_linked_tagnum(&G__G__HistLN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_TFractionFitter))) {
     TFractionFitter *G__Lderived;
     G__Lderived=(TFractionFitter*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TFractionFitter),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_TVirtualHistPainter))) {
     TVirtualHistPainter *G__Lderived;
     G__Lderived=(TVirtualHistPainter*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TVirtualHistPainter),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_TH2D))) {
     TH2D *G__Lderived;
     G__Lderived=(TH2D*)0x1000;
     {
       TH2 *G__Lpbase=(TH2*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH2D),G__get_linked_tagnum(&G__G__HistLN_TH2),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TH1 *G__Lpbase=(TH1*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH2D),G__get_linked_tagnum(&G__G__HistLN_TH1),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH2D),G__get_linked_tagnum(&G__G__HistLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH2D),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH2D),G__get_linked_tagnum(&G__G__HistLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH2D),G__get_linked_tagnum(&G__G__HistLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH2D),G__get_linked_tagnum(&G__G__HistLN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TArrayD *G__Lpbase=(TArrayD*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH2D),G__get_linked_tagnum(&G__G__HistLN_TArrayD),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TArray *G__Lpbase=(TArray*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH2D),G__get_linked_tagnum(&G__G__HistLN_TArray),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_TGraph2DErrors))) {
     TGraph2DErrors *G__Lderived;
     G__Lderived=(TGraph2DErrors*)0x1000;
     {
       TGraph2D *G__Lpbase=(TGraph2D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TGraph2DErrors),G__get_linked_tagnum(&G__G__HistLN_TGraph2D),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TGraph2DErrors),G__get_linked_tagnum(&G__G__HistLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TGraph2DErrors),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TGraph2DErrors),G__get_linked_tagnum(&G__G__HistLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TGraph2DErrors),G__get_linked_tagnum(&G__G__HistLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TGraph2DErrors),G__get_linked_tagnum(&G__G__HistLN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_TH1F))) {
     TH1F *G__Lderived;
     G__Lderived=(TH1F*)0x1000;
     {
       TH1 *G__Lpbase=(TH1*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH1F),G__get_linked_tagnum(&G__G__HistLN_TH1),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH1F),G__get_linked_tagnum(&G__G__HistLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH1F),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH1F),G__get_linked_tagnum(&G__G__HistLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH1F),G__get_linked_tagnum(&G__G__HistLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH1F),G__get_linked_tagnum(&G__G__HistLN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TArrayF *G__Lpbase=(TArrayF*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH1F),G__get_linked_tagnum(&G__G__HistLN_TArrayF),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TArray *G__Lpbase=(TArray*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH1F),G__get_linked_tagnum(&G__G__HistLN_TArray),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_TSpline))) {
     TSpline *G__Lderived;
     G__Lderived=(TSpline*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TSpline),G__get_linked_tagnum(&G__G__HistLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TSpline),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TSpline),G__get_linked_tagnum(&G__G__HistLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TSpline),G__get_linked_tagnum(&G__G__HistLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TSpline),G__get_linked_tagnum(&G__G__HistLN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_TGraphBentErrors))) {
     TGraphBentErrors *G__Lderived;
     G__Lderived=(TGraphBentErrors*)0x1000;
     {
       TGraph *G__Lpbase=(TGraph*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TGraphBentErrors),G__get_linked_tagnum(&G__G__HistLN_TGraph),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TGraphBentErrors),G__get_linked_tagnum(&G__G__HistLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TGraphBentErrors),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TGraphBentErrors),G__get_linked_tagnum(&G__G__HistLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TGraphBentErrors),G__get_linked_tagnum(&G__G__HistLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TGraphBentErrors),G__get_linked_tagnum(&G__G__HistLN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_TGraphDelaunay))) {
     TGraphDelaunay *G__Lderived;
     G__Lderived=(TGraphDelaunay*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TGraphDelaunay),G__get_linked_tagnum(&G__G__HistLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TGraphDelaunay),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_TGraphSmooth))) {
     TGraphSmooth *G__Lderived;
     G__Lderived=(TGraphSmooth*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TGraphSmooth),G__get_linked_tagnum(&G__G__HistLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TGraphSmooth),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_TGraphTime))) {
     TGraphTime *G__Lderived;
     G__Lderived=(TGraphTime*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TGraphTime),G__get_linked_tagnum(&G__G__HistLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TGraphTime),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_TArrayF))) {
     TArrayF *G__Lderived;
     G__Lderived=(TArrayF*)0x1000;
     {
       TArray *G__Lpbase=(TArray*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TArrayF),G__get_linked_tagnum(&G__G__HistLN_TArray),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_TH1D))) {
     TH1D *G__Lderived;
     G__Lderived=(TH1D*)0x1000;
     {
       TH1 *G__Lpbase=(TH1*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH1D),G__get_linked_tagnum(&G__G__HistLN_TH1),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH1D),G__get_linked_tagnum(&G__G__HistLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH1D),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH1D),G__get_linked_tagnum(&G__G__HistLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH1D),G__get_linked_tagnum(&G__G__HistLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH1D),G__get_linked_tagnum(&G__G__HistLN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TArrayD *G__Lpbase=(TArrayD*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH1D),G__get_linked_tagnum(&G__G__HistLN_TArrayD),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TArray *G__Lpbase=(TArray*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH1D),G__get_linked_tagnum(&G__G__HistLN_TArray),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_TH1C))) {
     TH1C *G__Lderived;
     G__Lderived=(TH1C*)0x1000;
     {
       TH1 *G__Lpbase=(TH1*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH1C),G__get_linked_tagnum(&G__G__HistLN_TH1),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH1C),G__get_linked_tagnum(&G__G__HistLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH1C),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH1C),G__get_linked_tagnum(&G__G__HistLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH1C),G__get_linked_tagnum(&G__G__HistLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH1C),G__get_linked_tagnum(&G__G__HistLN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TArrayC *G__Lpbase=(TArrayC*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH1C),G__get_linked_tagnum(&G__G__HistLN_TArrayC),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TArray *G__Lpbase=(TArray*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH1C),G__get_linked_tagnum(&G__G__HistLN_TArray),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_TH1S))) {
     TH1S *G__Lderived;
     G__Lderived=(TH1S*)0x1000;
     {
       TH1 *G__Lpbase=(TH1*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH1S),G__get_linked_tagnum(&G__G__HistLN_TH1),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH1S),G__get_linked_tagnum(&G__G__HistLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH1S),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH1S),G__get_linked_tagnum(&G__G__HistLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH1S),G__get_linked_tagnum(&G__G__HistLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH1S),G__get_linked_tagnum(&G__G__HistLN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TArrayS *G__Lpbase=(TArrayS*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH1S),G__get_linked_tagnum(&G__G__HistLN_TArrayS),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TArray *G__Lpbase=(TArray*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH1S),G__get_linked_tagnum(&G__G__HistLN_TArray),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_TH1I))) {
     TH1I *G__Lderived;
     G__Lderived=(TH1I*)0x1000;
     {
       TH1 *G__Lpbase=(TH1*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH1I),G__get_linked_tagnum(&G__G__HistLN_TH1),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH1I),G__get_linked_tagnum(&G__G__HistLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH1I),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH1I),G__get_linked_tagnum(&G__G__HistLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH1I),G__get_linked_tagnum(&G__G__HistLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH1I),G__get_linked_tagnum(&G__G__HistLN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TArrayI *G__Lpbase=(TArrayI*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH1I),G__get_linked_tagnum(&G__G__HistLN_TArrayI),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TArray *G__Lpbase=(TArray*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH1I),G__get_linked_tagnum(&G__G__HistLN_TArray),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_TH1K))) {
     TH1K *G__Lderived;
     G__Lderived=(TH1K*)0x1000;
     {
       TH1 *G__Lpbase=(TH1*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH1K),G__get_linked_tagnum(&G__G__HistLN_TH1),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH1K),G__get_linked_tagnum(&G__G__HistLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH1K),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH1K),G__get_linked_tagnum(&G__G__HistLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH1K),G__get_linked_tagnum(&G__G__HistLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH1K),G__get_linked_tagnum(&G__G__HistLN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TArrayF *G__Lpbase=(TArrayF*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH1K),G__get_linked_tagnum(&G__G__HistLN_TArrayF),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TArray *G__Lpbase=(TArray*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH1K),G__get_linked_tagnum(&G__G__HistLN_TArray),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_TProfile))) {
     TProfile *G__Lderived;
     G__Lderived=(TProfile*)0x1000;
     {
       TH1D *G__Lpbase=(TH1D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TProfile),G__get_linked_tagnum(&G__G__HistLN_TH1D),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TH1 *G__Lpbase=(TH1*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TProfile),G__get_linked_tagnum(&G__G__HistLN_TH1),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TProfile),G__get_linked_tagnum(&G__G__HistLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TProfile),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TProfile),G__get_linked_tagnum(&G__G__HistLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TProfile),G__get_linked_tagnum(&G__G__HistLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TProfile),G__get_linked_tagnum(&G__G__HistLN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TArrayD *G__Lpbase=(TArrayD*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TProfile),G__get_linked_tagnum(&G__G__HistLN_TArrayD),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TArray *G__Lpbase=(TArray*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TProfile),G__get_linked_tagnum(&G__G__HistLN_TArray),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_TH2C))) {
     TH2C *G__Lderived;
     G__Lderived=(TH2C*)0x1000;
     {
       TH2 *G__Lpbase=(TH2*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH2C),G__get_linked_tagnum(&G__G__HistLN_TH2),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TH1 *G__Lpbase=(TH1*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH2C),G__get_linked_tagnum(&G__G__HistLN_TH1),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH2C),G__get_linked_tagnum(&G__G__HistLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH2C),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH2C),G__get_linked_tagnum(&G__G__HistLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH2C),G__get_linked_tagnum(&G__G__HistLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH2C),G__get_linked_tagnum(&G__G__HistLN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TArrayC *G__Lpbase=(TArrayC*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH2C),G__get_linked_tagnum(&G__G__HistLN_TArrayC),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TArray *G__Lpbase=(TArray*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH2C),G__get_linked_tagnum(&G__G__HistLN_TArray),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_TH2S))) {
     TH2S *G__Lderived;
     G__Lderived=(TH2S*)0x1000;
     {
       TH2 *G__Lpbase=(TH2*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH2S),G__get_linked_tagnum(&G__G__HistLN_TH2),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TH1 *G__Lpbase=(TH1*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH2S),G__get_linked_tagnum(&G__G__HistLN_TH1),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH2S),G__get_linked_tagnum(&G__G__HistLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH2S),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH2S),G__get_linked_tagnum(&G__G__HistLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH2S),G__get_linked_tagnum(&G__G__HistLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH2S),G__get_linked_tagnum(&G__G__HistLN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TArrayS *G__Lpbase=(TArrayS*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH2S),G__get_linked_tagnum(&G__G__HistLN_TArrayS),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TArray *G__Lpbase=(TArray*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH2S),G__get_linked_tagnum(&G__G__HistLN_TArray),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_TH2I))) {
     TH2I *G__Lderived;
     G__Lderived=(TH2I*)0x1000;
     {
       TH2 *G__Lpbase=(TH2*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH2I),G__get_linked_tagnum(&G__G__HistLN_TH2),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TH1 *G__Lpbase=(TH1*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH2I),G__get_linked_tagnum(&G__G__HistLN_TH1),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH2I),G__get_linked_tagnum(&G__G__HistLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH2I),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH2I),G__get_linked_tagnum(&G__G__HistLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH2I),G__get_linked_tagnum(&G__G__HistLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH2I),G__get_linked_tagnum(&G__G__HistLN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TArrayI *G__Lpbase=(TArrayI*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH2I),G__get_linked_tagnum(&G__G__HistLN_TArrayI),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TArray *G__Lpbase=(TArray*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH2I),G__get_linked_tagnum(&G__G__HistLN_TArray),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_TH2F))) {
     TH2F *G__Lderived;
     G__Lderived=(TH2F*)0x1000;
     {
       TH2 *G__Lpbase=(TH2*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH2F),G__get_linked_tagnum(&G__G__HistLN_TH2),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TH1 *G__Lpbase=(TH1*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH2F),G__get_linked_tagnum(&G__G__HistLN_TH1),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH2F),G__get_linked_tagnum(&G__G__HistLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH2F),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH2F),G__get_linked_tagnum(&G__G__HistLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH2F),G__get_linked_tagnum(&G__G__HistLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH2F),G__get_linked_tagnum(&G__G__HistLN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TArrayF *G__Lpbase=(TArrayF*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH2F),G__get_linked_tagnum(&G__G__HistLN_TArrayF),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TArray *G__Lpbase=(TArray*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH2F),G__get_linked_tagnum(&G__G__HistLN_TArray),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_TH2PolyBin))) {
     TH2PolyBin *G__Lderived;
     G__Lderived=(TH2PolyBin*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH2PolyBin),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_TH2Poly))) {
     TH2Poly *G__Lderived;
     G__Lderived=(TH2Poly*)0x1000;
     {
       TH2 *G__Lpbase=(TH2*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH2Poly),G__get_linked_tagnum(&G__G__HistLN_TH2),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TH1 *G__Lpbase=(TH1*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH2Poly),G__get_linked_tagnum(&G__G__HistLN_TH1),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH2Poly),G__get_linked_tagnum(&G__G__HistLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH2Poly),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH2Poly),G__get_linked_tagnum(&G__G__HistLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH2Poly),G__get_linked_tagnum(&G__G__HistLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH2Poly),G__get_linked_tagnum(&G__G__HistLN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_TProfile2D))) {
     TProfile2D *G__Lderived;
     G__Lderived=(TProfile2D*)0x1000;
     {
       TH2D *G__Lpbase=(TH2D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TProfile2D),G__get_linked_tagnum(&G__G__HistLN_TH2D),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TH2 *G__Lpbase=(TH2*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TProfile2D),G__get_linked_tagnum(&G__G__HistLN_TH2),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TH1 *G__Lpbase=(TH1*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TProfile2D),G__get_linked_tagnum(&G__G__HistLN_TH1),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TProfile2D),G__get_linked_tagnum(&G__G__HistLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TProfile2D),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TProfile2D),G__get_linked_tagnum(&G__G__HistLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TProfile2D),G__get_linked_tagnum(&G__G__HistLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TProfile2D),G__get_linked_tagnum(&G__G__HistLN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TArrayD *G__Lpbase=(TArrayD*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TProfile2D),G__get_linked_tagnum(&G__G__HistLN_TArrayD),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TArray *G__Lpbase=(TArray*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TProfile2D),G__get_linked_tagnum(&G__G__HistLN_TArray),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_TH3))) {
     TH3 *G__Lderived;
     G__Lderived=(TH3*)0x1000;
     {
       TH1 *G__Lpbase=(TH1*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH3),G__get_linked_tagnum(&G__G__HistLN_TH1),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH3),G__get_linked_tagnum(&G__G__HistLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH3),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH3),G__get_linked_tagnum(&G__G__HistLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH3),G__get_linked_tagnum(&G__G__HistLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH3),G__get_linked_tagnum(&G__G__HistLN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH3),G__get_linked_tagnum(&G__G__HistLN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_TH3C))) {
     TH3C *G__Lderived;
     G__Lderived=(TH3C*)0x1000;
     {
       TH3 *G__Lpbase=(TH3*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH3C),G__get_linked_tagnum(&G__G__HistLN_TH3),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TH1 *G__Lpbase=(TH1*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH3C),G__get_linked_tagnum(&G__G__HistLN_TH1),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH3C),G__get_linked_tagnum(&G__G__HistLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH3C),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH3C),G__get_linked_tagnum(&G__G__HistLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH3C),G__get_linked_tagnum(&G__G__HistLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH3C),G__get_linked_tagnum(&G__G__HistLN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH3C),G__get_linked_tagnum(&G__G__HistLN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TArrayC *G__Lpbase=(TArrayC*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH3C),G__get_linked_tagnum(&G__G__HistLN_TArrayC),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TArray *G__Lpbase=(TArray*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH3C),G__get_linked_tagnum(&G__G__HistLN_TArray),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_TH3S))) {
     TH3S *G__Lderived;
     G__Lderived=(TH3S*)0x1000;
     {
       TH3 *G__Lpbase=(TH3*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH3S),G__get_linked_tagnum(&G__G__HistLN_TH3),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TH1 *G__Lpbase=(TH1*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH3S),G__get_linked_tagnum(&G__G__HistLN_TH1),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH3S),G__get_linked_tagnum(&G__G__HistLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH3S),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH3S),G__get_linked_tagnum(&G__G__HistLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH3S),G__get_linked_tagnum(&G__G__HistLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH3S),G__get_linked_tagnum(&G__G__HistLN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH3S),G__get_linked_tagnum(&G__G__HistLN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TArrayS *G__Lpbase=(TArrayS*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH3S),G__get_linked_tagnum(&G__G__HistLN_TArrayS),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TArray *G__Lpbase=(TArray*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH3S),G__get_linked_tagnum(&G__G__HistLN_TArray),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_TH3I))) {
     TH3I *G__Lderived;
     G__Lderived=(TH3I*)0x1000;
     {
       TH3 *G__Lpbase=(TH3*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH3I),G__get_linked_tagnum(&G__G__HistLN_TH3),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TH1 *G__Lpbase=(TH1*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH3I),G__get_linked_tagnum(&G__G__HistLN_TH1),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH3I),G__get_linked_tagnum(&G__G__HistLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH3I),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH3I),G__get_linked_tagnum(&G__G__HistLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH3I),G__get_linked_tagnum(&G__G__HistLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH3I),G__get_linked_tagnum(&G__G__HistLN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH3I),G__get_linked_tagnum(&G__G__HistLN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TArrayI *G__Lpbase=(TArrayI*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH3I),G__get_linked_tagnum(&G__G__HistLN_TArrayI),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TArray *G__Lpbase=(TArray*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH3I),G__get_linked_tagnum(&G__G__HistLN_TArray),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_TH3F))) {
     TH3F *G__Lderived;
     G__Lderived=(TH3F*)0x1000;
     {
       TH3 *G__Lpbase=(TH3*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH3F),G__get_linked_tagnum(&G__G__HistLN_TH3),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TH1 *G__Lpbase=(TH1*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH3F),G__get_linked_tagnum(&G__G__HistLN_TH1),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH3F),G__get_linked_tagnum(&G__G__HistLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH3F),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH3F),G__get_linked_tagnum(&G__G__HistLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH3F),G__get_linked_tagnum(&G__G__HistLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH3F),G__get_linked_tagnum(&G__G__HistLN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH3F),G__get_linked_tagnum(&G__G__HistLN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TArrayF *G__Lpbase=(TArrayF*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH3F),G__get_linked_tagnum(&G__G__HistLN_TArrayF),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TArray *G__Lpbase=(TArray*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH3F),G__get_linked_tagnum(&G__G__HistLN_TArray),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_TH3D))) {
     TH3D *G__Lderived;
     G__Lderived=(TH3D*)0x1000;
     {
       TH3 *G__Lpbase=(TH3*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH3D),G__get_linked_tagnum(&G__G__HistLN_TH3),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TH1 *G__Lpbase=(TH1*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH3D),G__get_linked_tagnum(&G__G__HistLN_TH1),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH3D),G__get_linked_tagnum(&G__G__HistLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH3D),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH3D),G__get_linked_tagnum(&G__G__HistLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH3D),G__get_linked_tagnum(&G__G__HistLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH3D),G__get_linked_tagnum(&G__G__HistLN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH3D),G__get_linked_tagnum(&G__G__HistLN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TArrayD *G__Lpbase=(TArrayD*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH3D),G__get_linked_tagnum(&G__G__HistLN_TArrayD),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TArray *G__Lpbase=(TArray*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TH3D),G__get_linked_tagnum(&G__G__HistLN_TArray),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_THLimitsFinder))) {
     THLimitsFinder *G__Lderived;
     G__Lderived=(THLimitsFinder*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_THLimitsFinder),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_THnSparseArrayChunk))) {
     THnSparseArrayChunk *G__Lderived;
     G__Lderived=(THnSparseArrayChunk*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_THnSparseArrayChunk),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArrayDgR))) {
     THnSparseT<TArrayD> *G__Lderived;
     G__Lderived=(THnSparseT<TArrayD>*)0x1000;
     {
       THnSparse *G__Lpbase=(THnSparse*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArrayDgR),G__get_linked_tagnum(&G__G__HistLN_THnSparse),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArrayDgR),G__get_linked_tagnum(&G__G__HistLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArrayDgR),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArrayFgR))) {
     THnSparseT<TArrayF> *G__Lderived;
     G__Lderived=(THnSparseT<TArrayF>*)0x1000;
     {
       THnSparse *G__Lpbase=(THnSparse*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArrayFgR),G__get_linked_tagnum(&G__G__HistLN_THnSparse),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArrayFgR),G__get_linked_tagnum(&G__G__HistLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArrayFgR),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArrayLgR))) {
     THnSparseT<TArrayL> *G__Lderived;
     G__Lderived=(THnSparseT<TArrayL>*)0x1000;
     {
       THnSparse *G__Lpbase=(THnSparse*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArrayLgR),G__get_linked_tagnum(&G__G__HistLN_THnSparse),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArrayLgR),G__get_linked_tagnum(&G__G__HistLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArrayLgR),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArrayIgR))) {
     THnSparseT<TArrayI> *G__Lderived;
     G__Lderived=(THnSparseT<TArrayI>*)0x1000;
     {
       THnSparse *G__Lpbase=(THnSparse*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArrayIgR),G__get_linked_tagnum(&G__G__HistLN_THnSparse),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArrayIgR),G__get_linked_tagnum(&G__G__HistLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArrayIgR),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArraySgR))) {
     THnSparseT<TArrayS> *G__Lderived;
     G__Lderived=(THnSparseT<TArrayS>*)0x1000;
     {
       THnSparse *G__Lpbase=(THnSparse*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArraySgR),G__get_linked_tagnum(&G__G__HistLN_THnSparse),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArraySgR),G__get_linked_tagnum(&G__G__HistLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArraySgR),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArrayCgR))) {
     THnSparseT<TArrayC> *G__Lderived;
     G__Lderived=(THnSparseT<TArrayC>*)0x1000;
     {
       THnSparse *G__Lpbase=(THnSparse*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArrayCgR),G__get_linked_tagnum(&G__G__HistLN_THnSparse),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArrayCgR),G__get_linked_tagnum(&G__G__HistLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArrayCgR),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_THStack))) {
     THStack *G__Lderived;
     G__Lderived=(THStack*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_THStack),G__get_linked_tagnum(&G__G__HistLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_THStack),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_TKDE))) {
     TKDE *G__Lderived;
     G__Lderived=(TKDE*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TKDE),G__get_linked_tagnum(&G__G__HistLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TKDE),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_TLimitDataSource))) {
     TLimitDataSource *G__Lderived;
     G__Lderived=(TLimitDataSource*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TLimitDataSource),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_TMultiDimFit))) {
     TMultiDimFit *G__Lderived;
     G__Lderived=(TMultiDimFit*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TMultiDimFit),G__get_linked_tagnum(&G__G__HistLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TMultiDimFit),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_TPolyMarker))) {
     TPolyMarker *G__Lderived;
     G__Lderived=(TPolyMarker*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TPolyMarker),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TPolyMarker),G__get_linked_tagnum(&G__G__HistLN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_TPrincipal))) {
     TPrincipal *G__Lderived;
     G__Lderived=(TPrincipal*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TPrincipal),G__get_linked_tagnum(&G__G__HistLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TPrincipal),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_TProfile3D))) {
     TProfile3D *G__Lderived;
     G__Lderived=(TProfile3D*)0x1000;
     {
       TH3D *G__Lpbase=(TH3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TProfile3D),G__get_linked_tagnum(&G__G__HistLN_TH3D),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TH3 *G__Lpbase=(TH3*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TProfile3D),G__get_linked_tagnum(&G__G__HistLN_TH3),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TH1 *G__Lpbase=(TH1*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TProfile3D),G__get_linked_tagnum(&G__G__HistLN_TH1),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TProfile3D),G__get_linked_tagnum(&G__G__HistLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TProfile3D),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TProfile3D),G__get_linked_tagnum(&G__G__HistLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TProfile3D),G__get_linked_tagnum(&G__G__HistLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TProfile3D),G__get_linked_tagnum(&G__G__HistLN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TProfile3D),G__get_linked_tagnum(&G__G__HistLN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TArrayD *G__Lpbase=(TArrayD*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TProfile3D),G__get_linked_tagnum(&G__G__HistLN_TArrayD),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TArray *G__Lpbase=(TArray*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TProfile3D),G__get_linked_tagnum(&G__G__HistLN_TArray),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_TSplinePoly))) {
     TSplinePoly *G__Lderived;
     G__Lderived=(TSplinePoly*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TSplinePoly),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_TSplinePoly3))) {
     TSplinePoly3 *G__Lderived;
     G__Lderived=(TSplinePoly3*)0x1000;
     {
       TSplinePoly *G__Lpbase=(TSplinePoly*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TSplinePoly3),G__get_linked_tagnum(&G__G__HistLN_TSplinePoly),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TSplinePoly3),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_TSplinePoly5))) {
     TSplinePoly5 *G__Lderived;
     G__Lderived=(TSplinePoly5*)0x1000;
     {
       TSplinePoly *G__Lpbase=(TSplinePoly*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TSplinePoly5),G__get_linked_tagnum(&G__G__HistLN_TSplinePoly),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TSplinePoly5),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_TSpline3))) {
     TSpline3 *G__Lderived;
     G__Lderived=(TSpline3*)0x1000;
     {
       TSpline *G__Lpbase=(TSpline*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TSpline3),G__get_linked_tagnum(&G__G__HistLN_TSpline),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TSpline3),G__get_linked_tagnum(&G__G__HistLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TSpline3),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TSpline3),G__get_linked_tagnum(&G__G__HistLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TSpline3),G__get_linked_tagnum(&G__G__HistLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TSpline3),G__get_linked_tagnum(&G__G__HistLN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_TSpline5))) {
     TSpline5 *G__Lderived;
     G__Lderived=(TSpline5*)0x1000;
     {
       TSpline *G__Lpbase=(TSpline*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TSpline5),G__get_linked_tagnum(&G__G__HistLN_TSpline),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TSpline5),G__get_linked_tagnum(&G__G__HistLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TSpline5),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TSpline5),G__get_linked_tagnum(&G__G__HistLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TSpline5),G__get_linked_tagnum(&G__G__HistLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TSpline5),G__get_linked_tagnum(&G__G__HistLN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_TSVDUnfold))) {
     TSVDUnfold *G__Lderived;
     G__Lderived=(TSVDUnfold*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TSVDUnfold),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_TUnfold))) {
     TUnfold *G__Lderived;
     G__Lderived=(TUnfold*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TUnfold),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_TUnfoldSys))) {
     TUnfoldSys *G__Lderived;
     G__Lderived=(TUnfoldSys*)0x1000;
     {
       TUnfold *G__Lpbase=(TUnfold*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TUnfoldSys),G__get_linked_tagnum(&G__G__HistLN_TUnfold),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TUnfoldSys),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_TVirtualGraphPainter))) {
     TVirtualGraphPainter *G__Lderived;
     G__Lderived=(TVirtualGraphPainter*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_TVirtualGraphPainter),G__get_linked_tagnum(&G__G__HistLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_ROOTcLcLMathcLcLWrappedMultiTF1))) {
     ROOT::Math::WrappedMultiTF1 *G__Lderived;
     G__Lderived=(ROOT::Math::WrappedMultiTF1*)0x1000;
     {
       ROOT::Math::IParametricGradFunctionMultiDim *G__Lpbase=(ROOT::Math::IParametricGradFunctionMultiDim*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_ROOTcLcLMathcLcLWrappedMultiTF1),G__get_linked_tagnum(&G__G__HistLN_ROOTcLcLMathcLcLIParametricGradFunctionMultiDim),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       ROOT::Math::IParametricFunctionMultiDim *G__Lpbase=(ROOT::Math::IParametricFunctionMultiDim*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_ROOTcLcLMathcLcLWrappedMultiTF1),G__get_linked_tagnum(&G__G__HistLN_ROOTcLcLMathcLcLIParametricFunctionMultiDim),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_ROOTcLcLMathcLcLWrappedMultiTF1),G__get_linked_tagnum(&G__G__HistLN_ROOTcLcLMathcLcLIBaseFunctionMultiDim),(long)G__2vbo_ROOTcLcLMathcLcLWrappedMultiTF1_ROOTcLcLMathcLcLIBaseFunctionMultiDim_2,1,2);
     }
     {
       ROOT::Math::IBaseParam *G__Lpbase=(ROOT::Math::IBaseParam*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_ROOTcLcLMathcLcLWrappedMultiTF1),G__get_linked_tagnum(&G__G__HistLN_ROOTcLcLMathcLcLIBaseParam),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__HistLN_ROOTcLcLMathcLcLWrappedTF1))) {
     ROOT::Math::WrappedTF1 *G__Lderived;
     G__Lderived=(ROOT::Math::WrappedTF1*)0x1000;
     {
       ROOT::Math::IParametricGradFunctionOneDim *G__Lpbase=(ROOT::Math::IParametricGradFunctionOneDim*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_ROOTcLcLMathcLcLWrappedTF1),G__get_linked_tagnum(&G__G__HistLN_ROOTcLcLMathcLcLIParametricGradFunctionOneDim),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       ROOT::Math::IParametricFunctionOneDim *G__Lpbase=(ROOT::Math::IParametricFunctionOneDim*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_ROOTcLcLMathcLcLWrappedTF1),G__get_linked_tagnum(&G__G__HistLN_ROOTcLcLMathcLcLIParametricFunctionOneDim),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_ROOTcLcLMathcLcLWrappedTF1),G__get_linked_tagnum(&G__G__HistLN_ROOTcLcLMathcLcLIBaseFunctionOneDim),(long)G__2vbo_ROOTcLcLMathcLcLWrappedTF1_ROOTcLcLMathcLcLIBaseFunctionOneDim_2,1,2);
     }
     {
       ROOT::Math::IBaseParam *G__Lpbase=(ROOT::Math::IBaseParam*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_ROOTcLcLMathcLcLWrappedTF1),G__get_linked_tagnum(&G__G__HistLN_ROOTcLcLMathcLcLIBaseParam),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       ROOT::Math::IGradientOneDim *G__Lpbase=(ROOT::Math::IGradientOneDim*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__HistLN_ROOTcLcLMathcLcLWrappedTF1),G__get_linked_tagnum(&G__G__HistLN_ROOTcLcLMathcLcLIGradientOneDim),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
}

/*********************************************************
* typedef information setup/
*********************************************************/
extern "C" void G__cpp_setup_typetableG__Hist() {

   /* Setting up typedef entry */
   G__search_typename2("Char_t",99,-1,0,-1);
   G__setnewtype(-1,"Signed Character 1 byte (char)",0);
   G__search_typename2("Int_t",105,-1,0,-1);
   G__setnewtype(-1,"Signed integer 4 bytes (int)",0);
   G__search_typename2("UInt_t",104,-1,0,-1);
   G__setnewtype(-1,"Unsigned integer 4 bytes (unsigned int)",0);
   G__search_typename2("Float_t",102,-1,0,-1);
   G__setnewtype(-1,"Float 4 bytes (float)",0);
   G__search_typename2("Double_t",100,-1,0,-1);
   G__setnewtype(-1,"Double 8 bytes",0);
   G__search_typename2("Bool_t",103,-1,0,-1);
   G__setnewtype(-1,"Boolean (0=false, 1=true) (bool)",0);
   G__search_typename2("Version_t",115,-1,0,-1);
   G__setnewtype(-1,"Class version identifier (short)",0);
   G__search_typename2("Option_t",99,-1,256,-1);
   G__setnewtype(-1,"Option string (const char)",0);
   G__search_typename2("Long64_t",110,-1,0,-1);
   G__setnewtype(-1,"Portable signed long integer 8 bytes",0);
   G__search_typename2("Axis_t",100,-1,0,-1);
   G__setnewtype(-1,"Axis values type (double)",0);
   G__search_typename2("Style_t",115,-1,0,-1);
   G__setnewtype(-1,"Style number (short)",0);
   G__search_typename2("Color_t",115,-1,0,-1);
   G__setnewtype(-1,"Color number (short)",0);
   G__search_typename2("vector<ROOT::TSchemaHelper>",117,G__get_linked_tagnum(&G__G__HistLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__HistLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__HistLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__HistLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__HistLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TVirtualArray*>",117,G__get_linked_tagnum(&G__G__HistLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__HistLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__HistLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__HistLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__HistLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("IMultiGenFunction",117,G__get_linked_tagnum(&G__G__HistLN_ROOTcLcLMathcLcLIBaseFunctionMultiDim),0,G__get_linked_tagnum(&G__G__HistLN_ROOTcLcLMath));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<ROOT::Fit::ParameterSettings>",117,G__get_linked_tagnum(&G__G__HistLN_vectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__HistLN_reverse_iteratorlEvectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__HistLN_vectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__HistLN_reverse_iteratorlEvectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__HistLN_vectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<unsigned int>",117,G__get_linked_tagnum(&G__G__HistLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__HistLN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__HistLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__HistLN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__HistLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<double>",117,G__get_linked_tagnum(&G__G__HistLN_vectorlEdoublecOallocatorlEdoublegRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__HistLN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__HistLN_vectorlEdoublecOallocatorlEdoublegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__HistLN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__HistLN_vectorlEdoublecOallocatorlEdoublegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<unsigned int,std::pair<double,double> >",117,G__get_linked_tagnum(&G__G__HistLN_maplEunsignedsPintcOpairlEdoublecOdoublegRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcOpairlEdoublecOdoublegRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<unsigned int,pair<double,double> >",117,G__get_linked_tagnum(&G__G__HistLN_maplEunsignedsPintcOpairlEdoublecOdoublegRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcOpairlEdoublecOdoublegRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<unsigned int,pair<double,double>,less<unsigned int> >",117,G__get_linked_tagnum(&G__G__HistLN_maplEunsignedsPintcOpairlEdoublecOdoublegRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcOpairlEdoublecOdoublegRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<std::string>",117,G__get_linked_tagnum(&G__G__HistLN_vectorlEstringcOallocatorlEstringgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__HistLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__HistLN_vectorlEstringcOallocatorlEstringgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__HistLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__HistLN_vectorlEstringcOallocatorlEstringgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<string>",117,G__get_linked_tagnum(&G__G__HistLN_vectorlEstringcOallocatorlEstringgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("auto_ptr<ROOT::Math::IMultiGenFunction>",117,G__get_linked_tagnum(&G__G__HistLN_auto_ptrlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<std::pair<double,double> >",117,G__get_linked_tagnum(&G__G__HistLN_vectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__HistLN_reverse_iteratorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__HistLN_vectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__HistLN_reverse_iteratorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__HistLN_vectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<pair<double,double> >",117,G__get_linked_tagnum(&G__G__HistLN_vectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<RangeSet>",117,G__get_linked_tagnum(&G__G__HistLN_vectorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRcOallocatorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__HistLN_reverse_iteratorlEvectorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRcOallocatorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__HistLN_vectorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRcOallocatorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__HistLN_reverse_iteratorlEvectorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRcOallocatorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__HistLN_vectorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRcOallocatorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<vector<pair<double,double>,allocator<pair<double,double> > > >",117,G__get_linked_tagnum(&G__G__HistLN_vectorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRcOallocatorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<const double*>",117,G__get_linked_tagnum(&G__G__HistLN_vectorlEconstsPdoublemUcOallocatorlEconstsPdoublemUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__HistLN_reverse_iteratorlEvectorlEconstsPdoublemUcOallocatorlEconstsPdoublemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__HistLN_vectorlEconstsPdoublemUcOallocatorlEconstsPdoublemUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__HistLN_reverse_iteratorlEvectorlEconstsPdoublemUcOallocatorlEconstsPdoublemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__HistLN_vectorlEconstsPdoublemUcOallocatorlEconstsPdoublemUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pair<Double_t,Double_t>",117,G__get_linked_tagnum(&G__G__HistLN_pairlEdoublecOdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<std::pair<Double_t,Double_t> >",117,G__get_linked_tagnum(&G__G__HistLN_vectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("iterator<std::bidirectional_iterator_tag,TObject*,std::ptrdiff_t,const TObject**,const TObject*&>",117,G__get_linked_tagnum(&G__G__HistLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("iterator<bidirectional_iterator_tag,TObject*>",117,G__get_linked_tagnum(&G__G__HistLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("iterator<bidirectional_iterator_tag,TObject*,long>",117,G__get_linked_tagnum(&G__G__HistLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("iterator<bidirectional_iterator_tag,TObject*,long,const TObject**>",117,G__get_linked_tagnum(&G__G__HistLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TFuncG",97,-1,0,G__get_linked_tagnum(&G__G__HistLN_TFormula));
   G__setnewtype(-1,"Double_t (TObject::*TFuncG)(const Double_t*,const Double_t*) const;",0);
   G__search_typename2("TMatrixTBase<Float_t>",117,G__get_linked_tagnum(&G__G__HistLN_TMatrixTBaselEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixFBase",117,G__get_linked_tagnum(&G__G__HistLN_TMatrixTBaselEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTBase<Double_t>",117,G__get_linked_tagnum(&G__G__HistLN_TMatrixTBaselEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixDBase",117,G__get_linked_tagnum(&G__G__HistLN_TMatrixTBaselEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TVectorT<Float_t>",117,G__get_linked_tagnum(&G__G__HistLN_TVectorTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TVectorF",117,G__get_linked_tagnum(&G__G__HistLN_TVectorTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TVectorT<Double_t>",117,G__get_linked_tagnum(&G__G__HistLN_TVectorTlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TVectorD",117,G__get_linked_tagnum(&G__G__HistLN_TVectorTlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSym<Double_t>",117,G__get_linked_tagnum(&G__G__HistLN_TMatrixTSymlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixDSym",117,G__get_linked_tagnum(&G__G__HistLN_TMatrixTSymlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTRow_const<Double_t>",117,G__get_linked_tagnum(&G__G__HistLN_TMatrixTRow_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTColumn_const<Double_t>",117,G__get_linked_tagnum(&G__G__HistLN_TMatrixTColumn_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTDiag_const<Double_t>",117,G__get_linked_tagnum(&G__G__HistLN_TMatrixTDiag_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTFlat_const<Double_t>",117,G__get_linked_tagnum(&G__G__HistLN_TMatrixTFlat_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSub_const<Double_t>",117,G__get_linked_tagnum(&G__G__HistLN_TMatrixTSub_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseRow_const<Double_t>",117,G__get_linked_tagnum(&G__G__HistLN_TMatrixTSparseRow_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseDiag_const<Double_t>",117,G__get_linked_tagnum(&G__G__HistLN_TMatrixTSparseDiag_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTRow<Double_t>",117,G__get_linked_tagnum(&G__G__HistLN_TMatrixTRowlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTColumn<Double_t>",117,G__get_linked_tagnum(&G__G__HistLN_TMatrixTColumnlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTDiag<Double_t>",117,G__get_linked_tagnum(&G__G__HistLN_TMatrixTDiaglEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTFlat<Double_t>",117,G__get_linked_tagnum(&G__G__HistLN_TMatrixTFlatlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSub<Double_t>",117,G__get_linked_tagnum(&G__G__HistLN_TMatrixTSublEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseRow<Double_t>",117,G__get_linked_tagnum(&G__G__HistLN_TMatrixTSparseRowlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseDiag<Double_t>",117,G__get_linked_tagnum(&G__G__HistLN_TMatrixTSparseDiaglEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TElementActionT<Double_t>",117,G__get_linked_tagnum(&G__G__HistLN_TElementActionTlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TElementPosActionT<Double_t>",117,G__get_linked_tagnum(&G__G__HistLN_TElementPosActionTlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("GenFuncG",89,-1,0,G__get_linked_tagnum(&G__G__HistLN_TFormulaPrimitive));
   G__setnewtype(-1,"Double_t (*GenFuncG)(const Double_t*,const Double_t*);",0);
   G__search_typename2("GenFunc0",89,-1,0,G__get_linked_tagnum(&G__G__HistLN_TFormulaPrimitive));
   G__setnewtype(-1,"Double_t (*GenFunc0)();",0);
   G__search_typename2("GenFunc10",89,-1,0,G__get_linked_tagnum(&G__G__HistLN_TFormulaPrimitive));
   G__setnewtype(-1,"Double_t (*GenFunc10)(Double_t);",0);
   G__search_typename2("GenFunc110",89,-1,0,G__get_linked_tagnum(&G__G__HistLN_TFormulaPrimitive));
   G__setnewtype(-1,"Double_t (*GenFunc110)(Double_t,Double_t);",0);
   G__search_typename2("GenFunc1110",89,-1,0,G__get_linked_tagnum(&G__G__HistLN_TFormulaPrimitive));
   G__setnewtype(-1,"Double_t (*GenFunc1110)(Double_t,Double_t, Double_t);",0);
   G__search_typename2("TFuncG",97,-1,0,G__get_linked_tagnum(&G__G__HistLN_TFormulaPrimitive));
   G__setnewtype(-1,"Double_t (TObject::*TFuncG)(const Double_t*,const Double_t*) const;",0);
   G__search_typename2("TFunc0",97,-1,0,G__get_linked_tagnum(&G__G__HistLN_TFormulaPrimitive));
   G__setnewtype(-1,"Double_t (TObject::*TFunc0)() const;",0);
   G__search_typename2("TFunc10",97,-1,0,G__get_linked_tagnum(&G__G__HistLN_TFormulaPrimitive));
   G__setnewtype(-1,"Double_t (TObject::*TFunc10)(Double_t) const;",0);
   G__search_typename2("TFunc110",97,-1,0,G__get_linked_tagnum(&G__G__HistLN_TFormulaPrimitive));
   G__setnewtype(-1,"Double_t (TObject::*TFunc110)(Double_t,Double_t) const;",0);
   G__search_typename2("TFunc1110",97,-1,0,G__get_linked_tagnum(&G__G__HistLN_TFormulaPrimitive));
   G__setnewtype(-1,"Double_t (TObject::*TFunc1110)(Double_t,Double_t,Double_t) const;",0);
   G__search_typename2("Bool_t (*)(const TGraph*, Int_t, Int_t)",49,-1,0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("THnSparseD",117,G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArrayDgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("THnSparseF",117,G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArrayFgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("THnSparseL",117,G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArrayLgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("THnSparseI",117,G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArrayIgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("THnSparseS",117,G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArraySgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("THnSparseC",117,G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArrayCgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("KernelFunction_Ptr",85,G__get_linked_tagnum(&G__G__HistLN_ROOTcLcLMathcLcLIBaseFunctionOneDim),0,G__get_linked_tagnum(&G__G__HistLN_TKDE));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<Double_t>",117,G__get_linked_tagnum(&G__G__HistLN_vectorlEdoublecOallocatorlEdoublegRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<UInt_t>",117,G__get_linked_tagnum(&G__G__HistLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<Bool_t>",117,G__get_linked_tagnum(&G__G__HistLN_vectorlEboolcOallocatorlEboolgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__HistLN_reverse_iteratorlEvectorlEboolcOallocatorlEboolgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__HistLN_vectorlEboolcOallocatorlEboolgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__HistLN_reverse_iteratorlEvectorlEboolcOallocatorlEboolgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__HistLN_vectorlEboolcOallocatorlEboolgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<bool>",117,G__get_linked_tagnum(&G__G__HistLN_vectorlEboolcOallocatorlEboolgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixT<Double_t>",117,G__get_linked_tagnum(&G__G__HistLN_TMatrixTlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixD",117,G__get_linked_tagnum(&G__G__HistLN_TMatrixTlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparse<Double_t>",117,G__get_linked_tagnum(&G__G__HistLN_TMatrixTSparselEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("BaseParamFunc",117,G__get_linked_tagnum(&G__G__HistLN_ROOTcLcLMathcLcLIParametricGradFunctionMultiDim),0,G__get_linked_tagnum(&G__G__HistLN_ROOTcLcLMathcLcLWrappedMultiTF1));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("BaseFunc",117,G__get_linked_tagnum(&G__G__HistLN_ROOTcLcLMathcLcLIBaseFunctionMultiDim),0,G__get_linked_tagnum(&G__G__HistLN_ROOTcLcLMathcLcLWrappedMultiTF1));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("IGrad",117,G__get_linked_tagnum(&G__G__HistLN_ROOTcLcLMathcLcLIGradientOneDim),0,G__get_linked_tagnum(&G__G__HistLN_ROOTcLcLMathcLcLWrappedTF1));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("BaseGradFunc",117,G__get_linked_tagnum(&G__G__HistLN_ROOTcLcLMathcLcLIParametricGradFunctionOneDim),0,G__get_linked_tagnum(&G__G__HistLN_ROOTcLcLMathcLcLWrappedTF1));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("BaseFunc",117,G__get_linked_tagnum(&G__G__HistLN_ROOTcLcLMathcLcLIBaseFunctionOneDim),0,G__get_linked_tagnum(&G__G__HistLN_ROOTcLcLMathcLcLWrappedTF1));
   G__setnewtype(-1,NULL,0);
}

/*********************************************************
* Data Member information setup/
*********************************************************/

   /* Setting up class,struct,union tag member variable */

   /* Foption_t */
static void G__setup_memvarFoption_t(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_Foption_t));
   { Foption_t *p; p=(Foption_t*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->Quiet)-(long)(p)),105,0,0,-1,-1,-1,1,"Quiet=",0,"\"Q\"  Quiet mode. No print");
   G__memvar_setup((void*)((long)(&p->Verbose)-(long)(p)),105,0,0,-1,-1,-1,1,"Verbose=",0,"\"V\"  Verbose mode. Print results after each iteration");
   G__memvar_setup((void*)((long)(&p->Bound)-(long)(p)),105,0,0,-1,-1,-1,1,"Bound=",0,"\"B\"  When using pre-defined functions user parameter settings are used instead of default one");
   G__memvar_setup((void*)((long)(&p->Chi2)-(long)(p)),105,0,0,-1,-1,-1,1,"Chi2=",0,"\"X\"  For fitting THnsparse use chi2 method (default is likelihood)");
   G__memvar_setup((void*)((long)(&p->Like)-(long)(p)),105,0,0,-1,-1,-1,1,"Like=",0,"\"L\"  Use Log Likelihood. Default is chisquare method except fitting THnsparse");
   G__memvar_setup((void*)((long)(&p->User)-(long)(p)),105,0,0,-1,-1,-1,1,"User=",0,"\"U\"  Use a User specified fitting algorithm (via SetFCN)");
   G__memvar_setup((void*)((long)(&p->W1)-(long)(p)),105,0,0,-1,-1,-1,1,"W1=",0,"\"W\"  Set all the weights to 1. Ignore error bars");
   G__memvar_setup((void*)((long)(&p->Errors)-(long)(p)),105,0,0,-1,-1,-1,1,"Errors=",0,"\"E\"  Performs a better error evaluation, calling HESSE and MINOS");
   G__memvar_setup((void*)((long)(&p->More)-(long)(p)),105,0,0,-1,-1,-1,1,"More=",0,"\"M\"  Improve fit results.");
   G__memvar_setup((void*)((long)(&p->Range)-(long)(p)),105,0,0,-1,-1,-1,1,"Range=",0,"\"R\"  Use the range stored in function");
   G__memvar_setup((void*)((long)(&p->Gradient)-(long)(p)),105,0,0,-1,-1,-1,1,"Gradient=",0,"\"G\"  Option to compute derivatives analytically");
   G__memvar_setup((void*)((long)(&p->Nostore)-(long)(p)),105,0,0,-1,-1,-1,1,"Nostore=",0,"\"N\"  If set, do not store the function graph");
   G__memvar_setup((void*)((long)(&p->Nograph)-(long)(p)),105,0,0,-1,-1,-1,1,"Nograph=",0,"\"0\"  If set, do not display the function graph");
   G__memvar_setup((void*)((long)(&p->Plus)-(long)(p)),105,0,0,-1,-1,-1,1,"Plus=",0,"\"+\"  Add new function (default is replace)");
   G__memvar_setup((void*)((long)(&p->Integral)-(long)(p)),105,0,0,-1,-1,-1,1,"Integral=",0,"\"I\"  Use function integral instead of function in center of bin");
   G__memvar_setup((void*)((long)(&p->Nochisq)-(long)(p)),105,0,0,-1,-1,-1,1,"Nochisq=",0,"\"C\"  In case of linear fitting, don't calculate the chisquare");
   G__memvar_setup((void*)((long)(&p->Minuit)-(long)(p)),105,0,0,-1,-1,-1,1,"Minuit=",0,"\"F\"  If fitting a polN, switch to minuit fitter");
   G__memvar_setup((void*)((long)(&p->NoErrX)-(long)(p)),105,0,0,-1,-1,-1,1,"NoErrX=",0,"\"EX0\" or \"T\" When fitting a TGraphErrors do not consider error in coordinates ");
   G__memvar_setup((void*)((long)(&p->Robust)-(long)(p)),105,0,0,-1,-1,-1,1,"Robust=",0,"\"ROB\" or \"H\":  For a TGraph use robust fitting");
   G__memvar_setup((void*)((long)(&p->StoreResult)-(long)(p)),105,0,0,-1,-1,-1,1,"StoreResult=",0,"\"S\": Stores the result in a TFitResult structure");
   G__memvar_setup((void*)((long)(&p->hRobust)-(long)(p)),100,0,0,-1,-1,-1,1,"hRobust=",0,"value of h parameter used in robust fitting ");
   }
   G__tag_memvar_reset();
}


   /* TH1 */
static void G__setup_memvarTH1(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TH1));
   { TH1 *p; p=(TH1*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNcells=",0,"number of bins(1D), cells (2D) +U/Overflows");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_TAxis),-1,-1,2,"fXaxis=",0,"X axis descriptor");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_TAxis),-1,-1,2,"fYaxis=",0,"Y axis descriptor");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_TAxis),-1,-1,2,"fZaxis=",0,"Z axis descriptor");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Short_t"),-1,2,"fBarOffset=",0,"(1000*offset) for bar charts or legos");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Short_t"),-1,2,"fBarWidth=",0,"(1000*width) for bar charts or legos");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fEntries=",0,"Number of entries");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTsumw=",0,"Total Sum of weights");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTsumw2=",0,"Total Sum of squares of weights");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTsumwx=",0,"Total Sum of weight*X");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTsumwx2=",0,"Total Sum of weight*X*X");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fMaximum=",0,"Maximum value for plotting");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fMinimum=",0,"Minimum value for plotting");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fNormFactor=",0,"Normalization factor");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_TArrayD),-1,-1,2,"fContour=",0,"Array to display contour levels");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_TArrayD),-1,-1,2,"fSumw2=",0,"Array of sum of squares of weights");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_TString),-1,-1,2,"fOption=",0,"histogram options");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TList),-1,-1,2,"fFunctions=",0,"->Pointer to list of functions (fits and user)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fBufferSize=",0,"fBuffer size");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fBuffer=",0,"[fBufferSize] entry buffer");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TDirectory),-1,-1,2,"fDirectory=",0,"!Pointer to directory holding this histogram");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fDimension=",0,"!Histogram dimension (1, 2 or 3 dim)");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fIntegral=",0,"!Integral of bins used by GetRandom");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TVirtualHistPainter),-1,-1,2,"fPainter=",0,"!pointer to histogram painter");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-2,2,"fgBufferSize=",0,"!default buffer size for automatic histograms");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-2,2,"fgAddDirectory=",0,"!flag to add histograms to the directory");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-2,2,"fgStatOverflows=",0,"!flag to use under/overflows in statistics");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-2,2,"fgDefaultSumw2=",0,"!flag to call TH1::Sumw2 automatically at histogram creation time");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TH1cLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kNoStats=%lldLL",(long long)TH1::kNoStats).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TH1cLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kUserContour=%lldLL",(long long)TH1::kUserContour).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TH1cLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kCanRebin=%lldLL",(long long)TH1::kCanRebin).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TH1cLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kLogX=%lldLL",(long long)TH1::kLogX).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TH1cLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kIsZoomed=%lldLL",(long long)TH1::kIsZoomed).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TH1cLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kNoTitle=%lldLL",(long long)TH1::kNoTitle).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TH1cLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kIsAverage=%lldLL",(long long)TH1::kIsAverage).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TH1cLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kNstat=%lldLL",(long long)TH1::kNstat).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* THnSparse */
static void G__setup_memvarTHnSparse(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_THnSparse));
   { THnSparse *p; p=(THnSparse*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNdimensions=",0,"number of dimensions");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fChunkSize=",0,"number of entries for each chunk");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fFilledBins=",0,"number of filled bins");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_TObjArray),-1,-1,4,"fAxes=",0,"axes of the histogram");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_TObjArray),-1,-1,4,"fBinContent=",0,"array of THnSparseArrayChunk");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_TExMap),-1,-1,4,"fBins=",0,"! filled bins");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_TExMap),-1,-1,4,"fBinsContinued=",0,"! filled bins for non-unique hashes, containing pairs of (bin index 0, bin index 1)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fEntries=",0,"number of entries, spread over chunks");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTsumw=",0,"total sum of weights");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTsumw2=",0,"total sum of weights squared; -1 if no errors are calculated");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_TArrayD),-1,-1,4,"fTsumwx=",0,"total sum of weight*X for each dimension");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_TArrayD),-1,-1,4,"fTsumwx2=",0,"total sum of weight*X*X for each dimension");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_THnSparseCompactBinCoord),-1,-1,4,"fCompactCoord=",0,"! compact coordinate");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,4,"fIntegral=",0,"! array with bin weight sums");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_THnSparsecLcLdA),-1,-2,4,"kNoInt=0LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_THnSparsecLcLdA),-1,-2,4,"kValidInt=1LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_THnSparsecLcLdA),-1,-2,4,"kInvalidInt=2LL",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__HistLN_THnSparsecLcLdA),-1,-1,4,"fIntegralStatus=",0,"! status of integral");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TF1 */
static void G__setup_memvarTF1(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TF1));
   { TF1 *p; p=(TF1*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fXmin=",0,"Lower bounds for the range");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fXmax=",0,"Upper bounds for the range");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNpx=",0,"Number of points used for the graphical representation");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fType=",0,"(=0 for standard functions, 1 if pointer to function)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNpfits=",0,"Number of points used in the fit");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNDF=",0,"Number of degrees of freedom in the fit");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNsave=",0,"Number of points used to fill array fSave");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fChisquare=",0,"Function fit chisquare");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fIntegral=",0,"![fNpx] Integral of function binned on fNpx bins");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fParErrors=",0,"[fNpar] Array of errors of the fNpar parameters");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fParMin=",0,"[fNpar] Array of lower limits of the fNpar parameters");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fParMax=",0,"[fNpar] Array of upper limits of the fNpar parameters");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fSave=",0,"[fNsave] Array of fNsave function values");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fAlpha=",0,"!Array alpha. for each bin in x the deconvolution r of fIntegral");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fBeta=",0,"!Array beta.  is approximated by x = alpha +beta*r *gamma*r**2");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fGamma=",0,"!Array gamma.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TObject),-1,-1,2,"fParent=",0,"!Parent object hooking this function (if one)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TH1),-1,-1,2,"fHistogram=",0,"!Pointer to histogram used for visualisation");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fMaximum=",0,"Maximum value for plotting");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fMinimum=",0,"Minimum value for plotting");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TMethodCall),-1,-1,2,"fMethodCall=",0,"!Pointer to MethodCall in case of interpreted function");
   G__memvar_setup((void*)0,89,0,0,-1,-1,-1,2,"fCintFunc=",0,"! pointer to interpreted function class");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_ROOTcLcLMathcLcLParamFunctor),-1,-1,2,"fFunctor=",0,"! Functor object to wrap any C++ callable object");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-2,2,"fgAbsValue=",0,"use absolute value of function when computing integral");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-2,2,"fgRejectPoint=",0,"True if point must be rejected in a fit");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TF1),-1,-2,2,"fgCurrent=",0,"pointer to current function being processed");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TF1cLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kNotDraw=%lldLL",(long long)TF1::kNotDraw).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TF2 */
static void G__setup_memvarTF2(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TF2));
   { TF2 *p; p=(TF2*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fYmin=",0,"Lower bound for the range in y");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fYmax=",0,"Upper bound for the range in y");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNpy=",0,"Number of points along y used for the graphical representation");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_TArrayD),-1,-1,2,"fContour=",0,"Array to display contour levels");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGraph */
static void G__setup_memvarTGraph(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TGraph));
   { TGraph *p; p=(TGraph*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMaxSize=",0,"!Current dimension of arrays fX and fY");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNpoints=",0,"Number of points <= fMaxSize");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fX=",0,"[fNpoints] array of X points");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fY=",0,"[fNpoints] array of Y points");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TList),-1,-1,2,"fFunctions=",0,"Pointer to list of functions (fits and user)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TH1F),-1,-1,2,"fHistogram=",0,"Pointer to histogram used for drawing axis");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fMinimum=",0,"Minimum value for plotting along y");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fMaximum=",0,"Maximum value for plotting along y");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TGraphcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kClipFrame=%lldLL",(long long)TGraph::kClipFrame).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TGraphcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kNotEditable=%lldLL",(long long)TGraph::kNotEditable).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGraphErrors */
static void G__setup_memvarTGraphErrors(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TGraphErrors));
   { TGraphErrors *p; p=(TGraphErrors*)0x1000; if (p) { }
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fEX=",0,"[fNpoints] array of X errors");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fEY=",0,"[fNpoints] array of Y errors");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGraph2D */
static void G__setup_memvarTGraph2D(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TGraph2D));
   { TGraph2D *p; p=(TGraph2D*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNpoints=",0,"Number of points in the data set");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNpx=",0,"Number of bins along X in fHistogram");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNpy=",0,"Number of bins along Y in fHistogram");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMaxIter=",0,"Maximum number of iterations to find Delaunay t>");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fSize=",0,"!Real size of fX, fY and fZ");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fX=",0,"[fNpoints]");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fY=",0,"[fNpoints] Data set to be plotted");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fZ=",0,"[fNpoints]");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fMinimum=",0,"Minimum value for plotting along z");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fMaximum=",0,"Maximum value for plotting along z");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fMargin=",0,"Extra space (in %) around interpolated area for fHistogram");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fZout=",0,"fHistogram bin height for points lying outside the interpolated area");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TList),-1,-1,2,"fFunctions=",0,"Pointer to list of functions (fits and user)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TH2D),-1,-1,2,"fHistogram=",0,"!2D histogram of z values linearly interpolated");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TDirectory),-1,-1,2,"fDirectory=",0,"!Pointer to directory holding this 2D graph");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TVirtualHistPainter),-1,-1,2,"fPainter=",0,"!pointer to histogram painter");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fUserHisto=",0,"True when SetHistogram has been called");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMultiGraph */
static void G__setup_memvarTMultiGraph(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TMultiGraph));
   { TMultiGraph *p; p=(TMultiGraph*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TList),-1,-1,2,"fGraphs=",0,"Pointer to list of TGraphs");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TList),-1,-1,2,"fFunctions=",0,"Pointer to list of functions (fits and user)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TH1F),-1,-1,2,"fHistogram=",0,"Pointer to histogram used for drawing axis");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fMaximum=",0,"Maximum value for plotting along y");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fMinimum=",0,"Minimum value for plotting along y");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TFitResult */
static void G__setup_memvarTFitResult(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TFitResult));
   { TFitResult *p; p=(TFitResult*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TFitResultPtr */
static void G__setup_memvarTFitResultPtr(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TFitResultPtr));
   { TFitResultPtr *p; p=(TFitResultPtr*)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,105,0,0,-1,-1,-1,4,"fStatus=",0,"fit status code");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TFitResult),-1,-1,4,"fPointer=",0,"Smart Pointer to TFitResult class  ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* ROOT::Fit */
static void G__setup_memvarROOTcLcLFit(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_ROOTcLcLFit));
   {
   }
   G__tag_memvar_reset();
}


   /* TAxis */
static void G__setup_memvarTAxis(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TAxis));
   { TAxis *p; p=(TAxis*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNbins=",0,"Number of bins");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fXmin=",0,"low edge of first bin");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fXmax=",0,"upper edge of last bin");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_TArrayD),-1,-1,4,"fXbins=",0,"Bin edges array in X");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fFirst=",0,"first bin to display");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fLast=",0,"last bin to display");
   G__memvar_setup((void*)0,114,0,0,-1,G__defined_typename("UShort_t"),-1,4,"fBits2=",0,"second bit status word");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fTimeDisplay=",0,"on/off displaying time values instead of numerics");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_TString),-1,-1,4,"fTimeFormat=",0,"Date&time format, ex: 09/12/99 12:34:00");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TObject),-1,-1,4,"fParent=",0,"!Object owning this axis");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_THashList),-1,-1,4,"fLabels=",0,"List of labels");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TAxiscLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kTickPlus=%lldLL",(long long)TAxis::kTickPlus).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TAxiscLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kTickMinus=%lldLL",(long long)TAxis::kTickMinus).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TAxiscLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kAxisRange=%lldLL",(long long)TAxis::kAxisRange).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TAxiscLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kCenterTitle=%lldLL",(long long)TAxis::kCenterTitle).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TAxiscLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kCenterLabels=%lldLL",(long long)TAxis::kCenterLabels).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TAxiscLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kRotateTitle=%lldLL",(long long)TAxis::kRotateTitle).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TAxiscLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kPalette=%lldLL",(long long)TAxis::kPalette).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TAxiscLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kNoExponent=%lldLL",(long long)TAxis::kNoExponent).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TAxiscLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kLabelsHori=%lldLL",(long long)TAxis::kLabelsHori).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TAxiscLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kLabelsVert=%lldLL",(long long)TAxis::kLabelsVert).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TAxiscLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kLabelsDown=%lldLL",(long long)TAxis::kLabelsDown).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TAxiscLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kLabelsUp=%lldLL",(long long)TAxis::kLabelsUp).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TAxiscLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kIsInteger=%lldLL",(long long)TAxis::kIsInteger).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TAxiscLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kMoreLogLabels=%lldLL",(long long)TAxis::kMoreLogLabels).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TAxiscLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kDecimals=%lldLL",(long long)TAxis::kDecimals).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TBackCompFitter */
static void G__setup_memvarTBackCompFitter(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TBackCompFitter));
   { TBackCompFitter *p; p=(TBackCompFitter*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TBackCompFittercLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kCanDeleteLast=%lldLL",(long long)TBackCompFitter::kCanDeleteLast).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_auto_ptrlEROOTcLcLFitcLcLFitDatagR),-1,-1,4,"fFitData=",0,"! data of the fit (managed by TBackCompFitter)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_auto_ptrlEROOTcLcLFitcLcLFittergR),-1,-1,4,"fFitter=",0,"! pointer to fitter object (managed by TBackCompFitter)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_ROOTcLcLMathcLcLMinimizer),-1,-1,4,"fMinimizer=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_ROOTcLcLMathcLcLIBaseFunctionMultiDim),G__defined_typename("IMultiGenFunction"),-1,4,"fObjFunc=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_ROOTcLcLMathcLcLIParametricFunctionMultiDim),G__defined_typename("IParamMultiFunction"),-1,4,"fModelFunc=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,4,"fCovar=",0,"cached covariance matrix (NxN)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TBinomialEfficiencyFitter */
static void G__setup_memvarTBinomialEfficiencyFitter(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TBinomialEfficiencyFitter));
   { TBinomialEfficiencyFitter *p; p=(TBinomialEfficiencyFitter*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TH1),-1,-1,2,"fDenominator=",0,"Denominator histogram");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TH1),-1,-1,2,"fNumerator=",0,"Numerator histogram");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TF1),-1,-1,2,"fFunction=",0,"Function to fit");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fEpsilon=",0,"Precision required for function integration (option \"I\")");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fFitDone=",0,"Set to kTRUE when the fit has been done");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fAverage=",0,"True if the fit function must be averaged over the bin");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fRange=",0,"True if the fit range must be taken from the function range");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TVirtualFitter),-1,-2,2,"fgFitter=",0,"pointer to the real fitter");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TConfidenceLevel */
static void G__setup_memvarTConfidenceLevel(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TConfidenceLevel));
   { TConfidenceLevel *p; p=(TConfidenceLevel*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNNMC=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fDtot=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fStot=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fBtot=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTSD=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fNMC=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fMCL3S=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fMCL5S=",0,(char*)NULL);
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTSB=",0,"[fNNMC]");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTSS=",0,"[fNNMC]");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,4,"fLRS=",0,"[fNNMC]");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,4,"fLRB=",0,"[fNNMC]");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,4,"fISS=",0,"[fNNMC]");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,4,"fISB=",0,"[fNNMC]");
   G__memvar_setup((void*)0,100,0,1,-1,G__defined_typename("Double_t"),-2,4,"fgMCLM2S=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,1,-1,G__defined_typename("Double_t"),-2,4,"fgMCLM1S=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,1,-1,G__defined_typename("Double_t"),-2,4,"fgMCLMED=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,1,-1,G__defined_typename("Double_t"),-2,4,"fgMCLP1S=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,1,-1,G__defined_typename("Double_t"),-2,4,"fgMCLP2S=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,1,-1,G__defined_typename("Double_t"),-2,4,"fgMCL3S1S=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,1,-1,G__defined_typename("Double_t"),-2,4,"fgMCL5S1S=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,1,-1,G__defined_typename("Double_t"),-2,4,"fgMCL3S2S=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,1,-1,G__defined_typename("Double_t"),-2,4,"fgMCL5S2S=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGraphAsymmErrors */
static void G__setup_memvarTGraphAsymmErrors(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TGraphAsymmErrors));
   { TGraphAsymmErrors *p; p=(TGraphAsymmErrors*)0x1000; if (p) { }
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fEXlow=",0,"[fNpoints] array of X low errors");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fEXhigh=",0,"[fNpoints] array of X high errors");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fEYlow=",0,"[fNpoints] array of Y low errors");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fEYhigh=",0,"[fNpoints] array of Y high errors");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TH2 */
static void G__setup_memvarTH2(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TH2));
   { TH2 *p; p=(TH2*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fScalefactor=",0,"Scale factor");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTsumwy=",0,"Total Sum of weight*Y");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTsumwy2=",0,"Total Sum of weight*Y*Y");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTsumwxy=",0,"Total Sum of weight*X*Y");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEfficiency */
static void G__setup_memvarTEfficiency(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TEfficiency));
   { TEfficiency *p; p=(TEfficiency*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TEfficiencycLcLEStatOption),-1,-2,1,G__FastAllocString(2048).Format("kFCP=%lldLL",(long long)TEfficiency::kFCP).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TEfficiencycLcLEStatOption),-1,-2,1,G__FastAllocString(2048).Format("kFNormal=%lldLL",(long long)TEfficiency::kFNormal).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TEfficiencycLcLEStatOption),-1,-2,1,G__FastAllocString(2048).Format("kFWilson=%lldLL",(long long)TEfficiency::kFWilson).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TEfficiencycLcLEStatOption),-1,-2,1,G__FastAllocString(2048).Format("kFAC=%lldLL",(long long)TEfficiency::kFAC).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TEfficiencycLcLEStatOption),-1,-2,1,G__FastAllocString(2048).Format("kFFC=%lldLL",(long long)TEfficiency::kFFC).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TEfficiencycLcLEStatOption),-1,-2,1,G__FastAllocString(2048).Format("kBJeffrey=%lldLL",(long long)TEfficiency::kBJeffrey).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TEfficiencycLcLEStatOption),-1,-2,1,G__FastAllocString(2048).Format("kBUniform=%lldLL",(long long)TEfficiency::kBUniform).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TEfficiencycLcLEStatOption),-1,-2,1,G__FastAllocString(2048).Format("kBBayesian=%lldLL",(long long)TEfficiency::kBBayesian).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fBeta_alpha=",0,"global parameter for prior beta distribution (default = 1)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fBeta_beta=",0,"global parameter for prior beta distribution (default = 1)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_vectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgR),G__defined_typename("vector<std::pair<Double_t,Double_t> >"),-1,2,"fBeta_bin_params=",0,"parameter for prior beta distribution different bin by bin ");
   G__memvar_setup((void*)0,49,0,0,-1,G__defined_typename("Double_t (*)(Int_t,Int_t,Double_t,Bool_t)"),-1,2,"fBoundary=",0,"!pointer to a method calculating the boundaries of confidence intervals");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fConfLevel=",0,"confidence level (default = 0.95)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TDirectory),-1,-1,2,"fDirectory=",0,"!pointer to directory holding this TEfficiency object");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TList),-1,-1,2,"fFunctions=",0,"->pointer to list of functions");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TGraphAsymmErrors),-1,-1,2,"fPaintGraph=",0,"!temporary graph for painting");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TH2),-1,-1,2,"fPaintHisto=",0,"!temporary histogram for painting      ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TH1),-1,-1,2,"fPassedHistogram=",0,"histogram for events which passed certain criteria");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__HistLN_TEfficiencycLcLEStatOption),-1,-1,2,"fStatisticOption=",0,"defines how the confidence intervals are determined");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TH1),-1,-1,2,"fTotalHistogram=",0,"histogram for total number of events");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fWeight=",0,"weight for all events (default = 1)");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TEfficiencycLcLdA),-1,-2,2,"kIsBayesian=16384LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TEfficiencycLcLdA),-1,-2,2,"kPosteriorMode=32768LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TEfficiencycLcLdA),-1,-2,2,"kShortestInterval=65536LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TEfficiencycLcLdA),-1,-2,2,"kUseBinPrior=131072LL",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TFormulaPrimitive */
static void G__setup_memvarTFormulaPrimitive(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TFormulaPrimitive));
   { TFormulaPrimitive *p; p=(TFormulaPrimitive*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TObjArray),-1,-2,2,"fgListOfFunction=",0,"!list of global primitive formulas ");
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("GenFuncG"),-1,2,"fFuncG=",0,"!pointer to the TFormula generic function");
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("GenFunc0"),-1,2,"fFunc0=",0,"!pointer to the function");
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("GenFunc10"),-1,2,"fFunc10=",0,"!pointer to the function");
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("GenFunc110"),-1,2,"fFunc110=",0,"!pointer to the function");
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("GenFunc1110"),-1,2,"fFunc1110=",0,"!pointer to the function");
   G__memvar_setup((void*)0,97,0,0,-1,G__defined_typename("TFuncG"),-1,2,"fTFuncG=",0,"!pointer to the TFormula generic function");
   G__memvar_setup((void*)0,97,0,0,-1,G__defined_typename("TFunc0"),-1,2,"fTFunc0=",0,"! pointer to member function");
   G__memvar_setup((void*)0,97,0,0,-1,G__defined_typename("TFunc10"),-1,2,"fTFunc10=",0,"! pointer to member function");
   G__memvar_setup((void*)0,97,0,0,-1,G__defined_typename("TFunc110"),-1,2,"fTFunc110=",0,"! pointer to member function");
   G__memvar_setup((void*)0,97,0,0,-1,G__defined_typename("TFunc1110"),-1,2,"fTFunc1110=",0,"! pointer to member function");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fType=",0,"type of the function  ");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNArguments=",0,"number of arguments");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNParameters=",0,"number of parameters");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsStatic=",0,"indication if the function is static");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TFormula */
static void G__setup_memvarTFormula(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TFormula));
   { TFormula *p; p=(TFormula*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNdim=",0,"Dimension of function (1=1-Dim, 2=2-Dim,etc)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNpar=",0,"Number of parameters");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNoper=",0,"Number of operators");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNconst=",0,"Number of constants");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNumber=",0,"formula number identifier");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNval=",0,"Number of different variables in expression");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNstring=",0,"Number of different constants character strings");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TString),-1,-1,2,"fExpr=",0,"[fNoper] List of expressions");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,4,"fOper=",0,"[fNoper] List of operators. (See documentation for changes made at version 7)");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fConst=",0,"[fNconst] Array of fNconst formula constants");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fParams=",0,"[fNpar] Array of fNpar parameters");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TString),-1,-1,2,"fNames=",0,"[fNpar] Array of parameter names");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_TObjArray),-1,-1,2,"fFunctions=",0,"Array of function calls to make");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_TObjArray),-1,-1,2,"fLinearParts=",0,"Linear parts if the formula is linear (contains '|' or \"++\")");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_TBits),-1,-1,2,"fAlreadyFound=",0,"! cache for information");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNOperOptimized=",0,"!Number of operators after optimization");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TString),-1,-1,2,"fExprOptimized=",0,"![fNOperOptimized] List of expressions");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fOperOptimized=",0,"![fNOperOptimized] List of operators. (See documentation for changes made at version 7)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TOperOffset),-1,-1,2,"fOperOffset=",0,"![fNOperOptimized]         Offsets of operrands");
   G__memvar_setup((void*)0,85,2,0,G__get_linked_tagnum(&G__G__HistLN_TFormulaPrimitive),-1,-1,2,"fPredefined=",0,"![fNPar] predefined function  ");
   G__memvar_setup((void*)0,97,0,0,-1,G__defined_typename("TFuncG"),-1,2,"fOptimal=",0,"!pointer to optimal function");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kEnd=0LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kAdd=1LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kSubstract=2LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kMultiply=3LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kDivide=4LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kModulo=5LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kcos=10LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"ksin=11LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"ktan=12LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kacos=13LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kasin=14LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"katan=15LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"katan2=16LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kfmod=17LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kpow=20LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"ksq=21LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"ksqrt=22LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kstrstr=23LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kmin=24LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kmax=25LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"klog=30LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kexp=31LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"klog10=32LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kpi=40LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kabs=41LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"ksign=42LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kint=43LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kSignInv=44LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"krndm=50LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kAnd=60LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kOr=61LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kEqual=62LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kNotEqual=63LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kLess=64LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kGreater=65LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kLessThan=66LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kGreaterThan=67LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kNot=68LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kcosh=70LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"ksinh=71LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"ktanh=72LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kacosh=73LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kasinh=74LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"katanh=75LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kStringEqual=76LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kStringNotEqual=77LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kBitAnd=78LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kBitOr=79LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kLeftShift=80LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kRightShift=81LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kJumpIf=82LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kJump=83LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kexpo=100LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kxexpo=100LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kyexpo=101LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kzexpo=102LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kxyexpo=105LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kgaus=110LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kxgaus=110LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kygaus=111LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kzgaus=112LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kxygaus=115LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"klandau=120LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kxlandau=120LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kylandau=121LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kzlandau=122LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kxylandau=125LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kpol=130LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kxpol=130LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kypol=131LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kzpol=132LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kParameter=140LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kConstant=141LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kBoolOptimize=142LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kStringConst=143LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kVariable=144LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kFunctionCall=145LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kData=146LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kUnary=147LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kBinary=148LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kThree=149LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kDefinedVariable=150LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kDefinedString=151LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kPlusD=152LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kPlusDD=153LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kMultD=154LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kMultDD=155LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kBoolOptimizeOr=156LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kBoolOptimizeAnd=157LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kBoolSet=158LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kFDM=159LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kFD0=160LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kFD1=161LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kFD2=162LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,2,"kFD3=163LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kNotGlobal=%lldLL",(long long)TFormula::kNotGlobal).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kNormalized=%lldLL",(long long)TFormula::kNormalized).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TFormulacLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kLinear=%lldLL",(long long)TFormula::kLinear).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TF12 */
static void G__setup_memvarTF12(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TF12));
   { TF12 *p; p=(TF12*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fXY=",0,"Value along Y (if projection X) or X (if projection Y)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fCase=",0,"projection along X(0), or Y(1)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TF2),-1,-1,2,"fF2=",0,"pointer to the mother TF2");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TF3 */
static void G__setup_memvarTF3(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TF3));
   { TF3 *p; p=(TF3*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fZmin=",0,"Lower bound for the range in z");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fZmax=",0,"Upper bound for the range in z");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNpz=",0,"Number of points along z used for the graphical representation");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TFractionFitter */
static void G__setup_memvarTFractionFitter(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TFractionFitter));
   { TFractionFitter *p; p=(TFractionFitter*)0x1000; if (p) { }
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fFitDone=",0,"flags whether a valid fit has been performed");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fLowLimitX=",0,"first bin in X dimension");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fHighLimitX=",0,"last  bin in X dimension");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fLowLimitY=",0,"first bin in Y dimension");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fHighLimitY=",0,"last  bin in Y dimension");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fLowLimitZ=",0,"first bin in Z dimension");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fHighLimitZ=",0,"last  bin in Z dimension");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNpfits=",0,"Number of points used in the fit");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNDF=",0,"Number of degrees of freedom in the fit");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fChisquare=",0,"Template fit chisquare");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_TObjArray),-1,-1,2,"fAji=",0,"array of pointers to predictions of real template distributions");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TH1),-1,-1,2,"fData=",0,"pointer to the \"data\" histogram to be fitted to");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_TObjArray),-1,-1,2,"fMCs=",0,"array of pointers to template histograms");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_TObjArray),-1,-1,2,"fWeights=",0,"array of pointers to corresponding weight factors (may be null)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fIntegralData=",0,"\"data\" histogram content integral over allowed fit range");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fIntegralMCs=",0,"same for template histograms (weights not taken into account)");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fFractions=",0,"template fractions scaled to the \"data\" histogram statistics");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TH1),-1,-1,2,"fPlot=",0,"pointer to histogram containing summed template predictions");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNpar=",0,"number of fit parameters");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TVirtualHistPainter */
static void G__setup_memvarTVirtualHistPainter(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TVirtualHistPainter));
   { TVirtualHistPainter *p; p=(TVirtualHistPainter*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgPainter=",0,"Pointer to class painter");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TH2D */
static void G__setup_memvarTH2D(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TH2D));
   { TH2D *p; p=(TH2D*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGraph2DErrors */
static void G__setup_memvarTGraph2DErrors(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TGraph2DErrors));
   { TGraph2DErrors *p; p=(TGraph2DErrors*)0x1000; if (p) { }
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fEX=",0,"[fNpoints] array of X errors");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fEY=",0,"[fNpoints] array of Y errors");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fEZ=",0,"[fNpoints] array of Z errors");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TH1F */
static void G__setup_memvarTH1F(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TH1F));
   { TH1F *p; p=(TH1F*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TSpline */
static void G__setup_memvarTSpline(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TSpline));
   { TSpline *p; p=(TSpline*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDelta=",0,"Distance between equidistant knots");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fXmin=",0,"Minimum value of abscissa");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fXmax=",0,"Maximum value of abscissa");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNp=",0,"Number of knots");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fKstep=",0,"True of equidistant knots");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TH1F),-1,-1,2,"fHistogram=",0,"Temporary histogram");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TGraph),-1,-1,2,"fGraph=",0,"Graph for drawing the knots");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNpx=",0,"Number of points used for graphical representation");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGraphBentErrors */
static void G__setup_memvarTGraphBentErrors(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TGraphBentErrors));
   { TGraphBentErrors *p; p=(TGraphBentErrors*)0x1000; if (p) { }
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fEXlow=",0,"[fNpoints] array of X low errors");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fEXhigh=",0,"[fNpoints] array of X high errors");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fEYlow=",0,"[fNpoints] array of Y low errors");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fEYhigh=",0,"[fNpoints] array of Y high errors");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fEXlowd=",0,"[fNpoints] array of X low displacements");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fEXhighd=",0,"[fNpoints] array of X high displacements");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fEYlowd=",0,"[fNpoints] array of Y low displacements");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fEYhighd=",0,"[fNpoints] array of Y high displacements");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGraphDelaunay */
static void G__setup_memvarTGraphDelaunay(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TGraphDelaunay));
   { TGraphDelaunay *p; p=(TGraphDelaunay*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNdt=",0,"!Number of Delaunay triangles found");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNpoints=",0,"!Number of data points in fGraph2D");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNhull=",0,"!Number of points in the hull");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fX=",0,"!Pointer to fGraph2D->fX");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fY=",0,"!Pointer to fGraph2D->fY");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fZ=",0,"!Pointer to fGraph2D->fZ");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fXN=",0,"!fGraph2D vectors normalized of size fNpoints");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fYN=",0,"!fGraph2D vectors normalized of size fNpoints");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fXNmin=",0,"!Minimum value of fXN");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fXNmax=",0,"!Maximum value of fXN");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fYNmin=",0,"!Minimum value of fYN");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fYNmax=",0,"!Maximum value of fYN");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fXoffset=",0,"!");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fYoffset=",0,"!Parameters used to normalize user data");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fXScaleFactor=",0,"!");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fYScaleFactor=",0,"!");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fZout=",0,"!Histogram bin height for points lying outside the convex hull");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDist=",0,"!Array used to order mass points by distance");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMaxIter=",0,"!Maximum number of iterations to find Delaunay triangles");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fTriedSize=",0,"!Real size of the fxTried arrays");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fPTried=",0,"!");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNTried=",0,"!Delaunay triangles storage of size fNdt");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMTried=",0,"!");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fHullPoints=",0,"!Hull points of size fNhull");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fOrder=",0,"!Array used to order mass points by distance");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fAllTri=",0,"!True if FindAllTriangles() has been performed on fGraph2D");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fInit=",0,"!True if CreateTrianglesDataStructure() and FindHull() have been performed");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TGraph2D),-1,-1,2,"fGraph2D=",0,"!2D graph containing the user data");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGraphSmooth */
static void G__setup_memvarTGraphSmooth(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TGraphSmooth));
   { TGraphSmooth *p; p=(TGraphSmooth*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNin=",0,"Number of input points");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNout=",0,"Number of output points");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TGraph),-1,-1,2,"fGin=",0,"Input graph");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TGraph),-1,-1,2,"fGout=",0,"Output graph");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fMinX=",0,"Minimum value of array X");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fMaxX=",0,"Maximum value of array X");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGraphTime */
static void G__setup_memvarTGraphTime(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TGraphTime));
   { TGraphTime *p; p=(TGraphTime*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fSleepTime=",0,"Time (msec) to wait between time steps");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNsteps=",0,"Number of time steps");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fXmin=",0,"Minimum for X axis");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fXmax=",0,"Maximum for X axis");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fYmin=",0,"Minimum for Y axis");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fYmax=",0,"Maximum for Y axis");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TObjArray),-1,-1,2,"fSteps=",0,"array of TLists for each time step");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TH1),-1,-1,2,"fFrame=",0,"TH1 object used for the pad range");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TH1D */
static void G__setup_memvarTH1D(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TH1D));
   { TH1D *p; p=(TH1D*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TH1C */
static void G__setup_memvarTH1C(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TH1C));
   { TH1C *p; p=(TH1C*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TH1S */
static void G__setup_memvarTH1S(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TH1S));
   { TH1S *p; p=(TH1S*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TH1I */
static void G__setup_memvarTH1I(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TH1I));
   { TH1I *p; p=(TH1I*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TH1K */
static void G__setup_memvarTH1K(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TH1K));
   { TH1K *p; p=(TH1K*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fReady=",0,"!");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNIn=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fKOrd=",0,"!");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fKCur=",0,"!");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TProfile */
static void G__setup_memvarTProfile(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TProfile));
   { TProfile *p; p=(TProfile*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_TArrayD),-1,-1,2,"fBinEntries=",0,"number of entries per bin");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__HistLN_EErrorType),-1,-1,2,"fErrorMode=",0,"Option to compute errors");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fYmin=",0,"Lower limit in Y (if set)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fYmax=",0,"Upper limit in Y (if set)");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fScaling=",0,"!True when TProfile::Scale is called");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTsumwy=",0,"Total Sum of weight*Y");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTsumwy2=",0,"Total Sum of weight*Y*Y");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_TArrayD),-1,-1,2,"fBinSumw2=",0,"Array of sum of squares of weights per bin ");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-2,2,"fgApproximate=",0,"bin error approximation option");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TH2C */
static void G__setup_memvarTH2C(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TH2C));
   { TH2C *p; p=(TH2C*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TH2S */
static void G__setup_memvarTH2S(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TH2S));
   { TH2S *p; p=(TH2S*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TH2I */
static void G__setup_memvarTH2I(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TH2I));
   { TH2I *p; p=(TH2I*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TH2F */
static void G__setup_memvarTH2F(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TH2F));
   { TH2F *p; p=(TH2F*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TH2PolyBin */
static void G__setup_memvarTH2PolyBin(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TH2PolyBin));
   { TH2PolyBin *p; p=(TH2PolyBin*)0x1000; if (p) { }
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fChanged=",0,"For the 3D Painter");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNumber=",0,"Bin number of the bin in TH2Poly");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TObject),-1,-1,2,"fPoly=",0,"Object holding the polygon definition");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fArea=",0,"Bin area");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fContent=",0,"Bin content");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fXmin=",0,"X minimum value");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fYmin=",0,"Y minimum value");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fXmax=",0,"X maximum value");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fYmax=",0,"Y maximum value");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TH2Poly */
static void G__setup_memvarTH2Poly(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TH2Poly));
   { TH2Poly *p; p=(TH2Poly*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TList),-1,-1,2,"fBins=",0,"List of bins.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fOverflow[9]=",0,"Overflow bins");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fCellX=",0,"Number of partition cells in the x-direction of the histogram");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fCellY=",0,"Number of partition cells in the y-direction of the histogram");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNCells=",0,"Number of partition cells: fCellX*fCellY");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TList),-1,-1,2,"fCells=",0,"[fNCells] The array of TLists that store the bins that intersect with each cell");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fStepX=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fStepY=",0,"Dimensions of a partition cell");
   G__memvar_setup((void*)0,71,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsEmpty=",0,"[fNCells] The array that returns true if the cell at the given coordinate is empty");
   G__memvar_setup((void*)0,71,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fCompletelyInside=",0,"[fNCells] The array that returns true if the cell at the given coordinate is completely inside a bin");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fFloat=",0,"When set to kTRUE, allows the histogram to expand if a bin outside the limits is added.");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fNewBinAdded=",0,"!For the 3D Painter");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fBinContentChanged=",0,"!For the 3D Painter");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TProfile2D */
static void G__setup_memvarTProfile2D(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TProfile2D));
   { TProfile2D *p; p=(TProfile2D*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_TArrayD),-1,-1,2,"fBinEntries=",0,"number of entries per bin");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__HistLN_EErrorType),-1,-1,2,"fErrorMode=",0,"Option to compute errors");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fZmin=",0,"Lower limit in Z (if set)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fZmax=",0,"Upper limit in Z (if set)");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fScaling=",0,"!True when TProfile2D::Scale is called");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTsumwz=",0,"Total Sum of weight*Z");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTsumwz2=",0,"Total Sum of weight*Z*Z");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_TArrayD),-1,-1,2,"fBinSumw2=",0,"Array of sum of squares of weights per bin ");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-2,2,"fgApproximate=",0,"bin error approximation option");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TH3 */
static void G__setup_memvarTH3(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TH3));
   { TH3 *p; p=(TH3*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTsumwy=",0,"Total Sum of weight*Y");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTsumwy2=",0,"Total Sum of weight*Y*Y");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTsumwxy=",0,"Total Sum of weight*X*Y");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTsumwz=",0,"Total Sum of weight*Z");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTsumwz2=",0,"Total Sum of weight*Z*Z");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTsumwxz=",0,"Total Sum of weight*X*Z");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTsumwyz=",0,"Total Sum of weight*Y*Z");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TH3C */
static void G__setup_memvarTH3C(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TH3C));
   { TH3C *p; p=(TH3C*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TH3S */
static void G__setup_memvarTH3S(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TH3S));
   { TH3S *p; p=(TH3S*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TH3I */
static void G__setup_memvarTH3I(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TH3I));
   { TH3I *p; p=(TH3I*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TH3F */
static void G__setup_memvarTH3F(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TH3F));
   { TH3F *p; p=(TH3F*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TH3D */
static void G__setup_memvarTH3D(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TH3D));
   { TH3D *p; p=(TH3D*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* THLimitsFinder */
static void G__setup_memvarTHLimitsFinder(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_THLimitsFinder));
   { THLimitsFinder *p; p=(THLimitsFinder*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_THLimitsFinder),-1,-2,2,"fgLimitsFinder=",0,"!Pointer to hist limits finder");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* THnSparseArrayChunk */
static void G__setup_memvarTHnSparseArrayChunk(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_THnSparseArrayChunk));
   { THnSparseArrayChunk *p; p=(THnSparseArrayChunk*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fCoordinateAllocationSize)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fCoordinateAllocationSize=",0,"! size of the allocated coordinate buffer; -1 means none or fCoordinatesSize");
   G__memvar_setup((void*)((long)(&p->fSingleCoordinateSize)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fSingleCoordinateSize=",0,"size of a single bin coordinate");
   G__memvar_setup((void*)((long)(&p->fCoordinatesSize)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fCoordinatesSize=",0,"size of the bin coordinate buffer");
   G__memvar_setup((void*)((long)(&p->fCoordinates)-(long)(p)),67,0,0,-1,G__defined_typename("Char_t"),-1,1,"fCoordinates=",0,"[fCoordinatesSize] compact bin coordinate buffer");
   G__memvar_setup((void*)((long)(&p->fContent)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__G__HistLN_TArray),-1,-1,1,"fContent=",0,"bin content");
   G__memvar_setup((void*)((long)(&p->fSumw2)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__G__HistLN_TArrayD),-1,-1,1,"fSumw2=",0,"bin errors");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* THnSparseT<TArrayD> */
static void G__setup_memvarTHnSparseTlETArrayDgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArrayDgR));
   { THnSparseT<TArrayD> *p; p=(THnSparseT<TArrayD>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* THnSparseT<TArrayF> */
static void G__setup_memvarTHnSparseTlETArrayFgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArrayFgR));
   { THnSparseT<TArrayF> *p; p=(THnSparseT<TArrayF>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* THnSparseT<TArrayL> */
static void G__setup_memvarTHnSparseTlETArrayLgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArrayLgR));
   { THnSparseT<TArrayL> *p; p=(THnSparseT<TArrayL>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* THnSparseT<TArrayI> */
static void G__setup_memvarTHnSparseTlETArrayIgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArrayIgR));
   { THnSparseT<TArrayI> *p; p=(THnSparseT<TArrayI>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* THnSparseT<TArrayS> */
static void G__setup_memvarTHnSparseTlETArraySgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArraySgR));
   { THnSparseT<TArrayS> *p; p=(THnSparseT<TArrayS>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* THnSparseT<TArrayC> */
static void G__setup_memvarTHnSparseTlETArrayCgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArrayCgR));
   { THnSparseT<TArrayC> *p; p=(THnSparseT<TArrayC>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* THStack */
static void G__setup_memvarTHStack(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_THStack));
   { THStack *p; p=(THStack*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TList),-1,-1,2,"fHists=",0,"Pointer to array of TH1");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TObjArray),-1,-1,2,"fStack=",0,"!Pointer to array of sums of TH1");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TH1),-1,-1,2,"fHistogram=",0,"Pointer to histogram used for drawing axis");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fMaximum=",0,"Maximum value for plotting along y");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fMinimum=",0,"Minimum value for plotting along y");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TKDE */
static void G__setup_memvarTKDE(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TKDE));
   { TKDE *p; p=(TKDE*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TKDEcLcLEKernelType),-1,-2,1,G__FastAllocString(2048).Format("kGaussian=%lldLL",(long long)TKDE::kGaussian).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TKDEcLcLEKernelType),-1,-2,1,G__FastAllocString(2048).Format("kEpanechnikov=%lldLL",(long long)TKDE::kEpanechnikov).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TKDEcLcLEKernelType),-1,-2,1,G__FastAllocString(2048).Format("kBiweight=%lldLL",(long long)TKDE::kBiweight).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TKDEcLcLEKernelType),-1,-2,1,G__FastAllocString(2048).Format("kCosineArch=%lldLL",(long long)TKDE::kCosineArch).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TKDEcLcLEKernelType),-1,-2,1,G__FastAllocString(2048).Format("kUserDefined=%lldLL",(long long)TKDE::kUserDefined).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TKDEcLcLEKernelType),-1,-2,1,G__FastAllocString(2048).Format("kTotalKernels=%lldLL",(long long)TKDE::kTotalKernels).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TKDEcLcLEIteration),-1,-2,1,G__FastAllocString(2048).Format("kAdaptive=%lldLL",(long long)TKDE::kAdaptive).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TKDEcLcLEIteration),-1,-2,1,G__FastAllocString(2048).Format("kFixed=%lldLL",(long long)TKDE::kFixed).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TKDEcLcLEMirror),-1,-2,1,G__FastAllocString(2048).Format("kNoMirror=%lldLL",(long long)TKDE::kNoMirror).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TKDEcLcLEMirror),-1,-2,1,G__FastAllocString(2048).Format("kMirrorLeft=%lldLL",(long long)TKDE::kMirrorLeft).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TKDEcLcLEMirror),-1,-2,1,G__FastAllocString(2048).Format("kMirrorRight=%lldLL",(long long)TKDE::kMirrorRight).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TKDEcLcLEMirror),-1,-2,1,G__FastAllocString(2048).Format("kMirrorBoth=%lldLL",(long long)TKDE::kMirrorBoth).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TKDEcLcLEMirror),-1,-2,1,G__FastAllocString(2048).Format("kMirrorAsymLeft=%lldLL",(long long)TKDE::kMirrorAsymLeft).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TKDEcLcLEMirror),-1,-2,1,G__FastAllocString(2048).Format("kMirrorAsymLeftRight=%lldLL",(long long)TKDE::kMirrorAsymLeftRight).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TKDEcLcLEMirror),-1,-2,1,G__FastAllocString(2048).Format("kMirrorAsymRight=%lldLL",(long long)TKDE::kMirrorAsymRight).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TKDEcLcLEMirror),-1,-2,1,G__FastAllocString(2048).Format("kMirrorLeftAsymRight=%lldLL",(long long)TKDE::kMirrorLeftAsymRight).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TKDEcLcLEMirror),-1,-2,1,G__FastAllocString(2048).Format("kMirrorAsymBoth=%lldLL",(long long)TKDE::kMirrorAsymBoth).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TKDEcLcLEBinning),-1,-2,1,G__FastAllocString(2048).Format("kUnbinned=%lldLL",(long long)TKDE::kUnbinned).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TKDEcLcLEBinning),-1,-2,1,G__FastAllocString(2048).Format("kRelaxedBinning=%lldLL",(long long)TKDE::kRelaxedBinning).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TKDEcLcLEBinning),-1,-2,1,G__FastAllocString(2048).Format("kForcedBinning=%lldLL",(long long)TKDE::kForcedBinning).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_ROOTcLcLMathcLcLIBaseFunctionOneDim),G__defined_typename("KernelFunction_Ptr"),-1,4,"fKernelFunction=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TKDEcLcLTKernel),-1,-1,4,"fKernel=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"fData=",0,"Data events");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"fEvents=",0,"Original data storage");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TF1),-1,-1,4,"fPDF=",0,"Output Kernel Density Estimation PDF function");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TF1),-1,-1,4,"fUpperPDF=",0,"Output Kernel Density Estimation upper confidence interval PDF function");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TF1),-1,-1,4,"fLowerPDF=",0,"Output Kernel Density Estimation lower confidence interval PDF function");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TF1),-1,-1,4,"fApproximateBias=",0,"Output Kernel Density Estimation approximate bias");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TGraphErrors),-1,-1,4,"fGraph=",0,"Graph with the errors");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__HistLN_TKDEcLcLEKernelType),-1,-1,4,"fKernelType=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__HistLN_TKDEcLcLEIteration),-1,-1,4,"fIteration=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__HistLN_TKDEcLcLEMirror),-1,-1,4,"fMirror=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__HistLN_TKDEcLcLEBinning),-1,-1,4,"fBinning=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fUseMirroring=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fMirrorLeft=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fMirrorRight=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fAsymLeft=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fAsymRight=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fUseBins=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fNewData=",0,"flag to control when new data are given");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fUseMinMaxFromData=",0,"flag top control if min and max must be used from data");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fNBins=",0,"Number of bins for binned data option");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fNEvents=",0,"Data's number of events");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fUseBinsNEvents=",0,"If the algorithm is allowed to use binning this is the minimum number of events to do so");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fMean=",0,"Data mean");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fSigma=",0,"Data std deviation");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fSigmaRob=",0,"Data std deviation (robust estimation)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fXMin=",0,"Data minimum value");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fXMax=",0,"Data maximum value");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fRho=",0,"Adjustment factor for sigma");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fAdaptiveBandwidthFactor=",0,"Geometric mean of the kernel density estimation from the data for adaptive iteration");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fWeightSize=",0,"Caches the weight size");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"fCanonicalBandwidths=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"fKernelSigmas2=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR),G__defined_typename("vector<UInt_t>"),-1,4,"fBinCount=",0,"Number of events per bin for binned data option");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_vectorlEboolcOallocatorlEboolgRsPgR),G__defined_typename("vector<Bool_t>"),-1,4,"fSettedOptions=",0,"User input options flag");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TLimitDataSource */
static void G__setup_memvarTLimitDataSource(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TLimitDataSource));
   { TLimitDataSource *p; p=(TLimitDataSource*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_TObjArray),-1,-1,4,"fSignal=",0,"packed input signal");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_TObjArray),-1,-1,4,"fBackground=",0,"packed input background");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_TObjArray),-1,-1,4,"fCandidates=",0,"packed input candidates (data)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_TObjArray),-1,-1,4,"fErrorOnSignal=",0,"packed error sources for signal");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_TObjArray),-1,-1,4,"fErrorOnBackground=",0,"packed error sources for background");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_TObjArray),-1,-1,4,"fIds=",0,"packed IDs for the different error sources");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_TObjArray),-1,-1,4,"fDummyTA=",0,"array of dummy object (used for bookeeping)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_TObjArray),-1,-1,4,"fDummyIds=",0,"array of dummy object (used for bookeeping)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TLimit */
static void G__setup_memvarTLimit(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TLimit));
   { TLimit *p; p=(TLimit*)0x1000; if (p) { }
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TArrayD),-1,-2,4,"fgTable=",0,"a log table... just to speed up calculation");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TOrdCollection),-1,-2,4,"fgSystNames=",0,"Collection of systematics names");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMultiDimFit */
static void G__setup_memvarTMultiDimFit(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TMultiDimFit));
   { TMultiDimFit *p; p=(TMultiDimFit*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TMultiDimFitcLcLEMDFPolyType),-1,-2,1,G__FastAllocString(2048).Format("kMonomials=%lldLL",(long long)TMultiDimFit::kMonomials).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TMultiDimFitcLcLEMDFPolyType),-1,-2,1,G__FastAllocString(2048).Format("kChebyshev=%lldLL",(long long)TMultiDimFit::kChebyshev).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TMultiDimFitcLcLEMDFPolyType),-1,-2,1,G__FastAllocString(2048).Format("kLegendre=%lldLL",(long long)TMultiDimFit::kLegendre).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TMultiDimFit),-1,-2,4,"fgInstance=",0,"Static instance");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_TVectorTlEdoublegR),G__defined_typename("TVectorD"),-1,2,"fQuantity=",0,"Training sample, dependent quantity");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_TVectorTlEdoublegR),G__defined_typename("TVectorD"),-1,2,"fSqError=",0,"Training sample, error in quantity");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fMeanQuantity=",0,"Mean of dependent quantity");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fMaxQuantity=",0,"Max value of dependent quantity");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fMinQuantity=",0,"Min value of dependent quantity");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fSumSqQuantity=",0,"SumSquare of dependent quantity");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fSumSqAvgQuantity=",0,"Sum of squares away from mean");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_TVectorTlEdoublegR),G__defined_typename("TVectorD"),-1,2,"fVariables=",0,"Training sample, independent variables");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNVariables=",0,"Number of independent variables");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_TVectorTlEdoublegR),G__defined_typename("TVectorD"),-1,2,"fMeanVariables=",0,"mean value of independent variables");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_TVectorTlEdoublegR),G__defined_typename("TVectorD"),-1,2,"fMaxVariables=",0,"max value of independent variables");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_TVectorTlEdoublegR),G__defined_typename("TVectorD"),-1,2,"fMinVariables=",0,"min value of independent variables");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fSampleSize=",0,"Size of training sample");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_TVectorTlEdoublegR),G__defined_typename("TVectorD"),-1,2,"fTestQuantity=",0,"Test sample, dependent quantity");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_TVectorTlEdoublegR),G__defined_typename("TVectorD"),-1,2,"fTestSqError=",0,"Test sample, Error in quantity");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_TVectorTlEdoublegR),G__defined_typename("TVectorD"),-1,2,"fTestVariables=",0,"Test sample, independent variables");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fTestSampleSize=",0,"Size of test sample");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fMinAngle=",0,"Min angle for acepting new function");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fMaxAngle=",0,"Max angle for acepting new function");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMaxTerms=",0,"Max terms expected in final expr.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fMinRelativeError=",0,"Min relative error accepted");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMaxPowers=",0,"[fNVariables] maximum powers");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPowerLimit=",0,"Control parameter");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_TMatrixTlEdoublegR),G__defined_typename("TMatrixD"),-1,2,"fFunctions=",0,"Functions evaluated over sample");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMaxFunctions=",0,"max number of functions");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fFunctionCodes=",0,"[fMaxFunctions] acceptance code");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMaxStudy=",0,"max functions to study");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMaxFuncNV=",0,"fMaxFunctions*fNVariables");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_TMatrixTlEdoublegR),G__defined_typename("TMatrixD"),-1,2,"fOrthFunctions=",0,"As above, but orthogonalised");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_TVectorTlEdoublegR),G__defined_typename("TVectorD"),-1,2,"fOrthFunctionNorms=",0,"Norm of the evaluated functions");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMaxPowersFinal=",0,"[fNVariables] maximum powers from fit;");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fPowers=",0,"[fMaxFuncNV] where fMaxFuncNV = fMaxFunctions*fNVariables");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fPowerIndex=",0,"[fMaxTerms] Index of accepted powers");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_TVectorTlEdoublegR),G__defined_typename("TVectorD"),-1,2,"fResiduals=",0,"Vector of the final residuals");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fMaxResidual=",0,"Max redsidual value");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fMinResidual=",0,"Min redsidual value");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMaxResidualRow=",0,"Row giving max residual");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMinResidualRow=",0,"Row giving min residual");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fSumSqResidual=",0,"Sum of Square residuals");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNCoefficients=",0,"Dimension of model coefficients");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_TVectorTlEdoublegR),G__defined_typename("TVectorD"),-1,2,"fOrthCoefficients=",0,"The model coefficients");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_TMatrixTlEdoublegR),G__defined_typename("TMatrixD"),-1,2,"fOrthCurvatureMatrix=",0,"Model matrix");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_TVectorTlEdoublegR),G__defined_typename("TVectorD"),-1,2,"fCoefficients=",0,"Vector of the final coefficients");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_TVectorTlEdoublegR),G__defined_typename("TVectorD"),-1,2,"fCoefficientsRMS=",0,"Vector of RMS of coefficients");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRMS=",0,"Root mean square of fit");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fChi2=",0,"Chi square of fit");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fParameterisationCode=",0,"Exit code of parameterisation");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fError=",0,"Error from parameterization");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTestError=",0,"Error from test");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPrecision=",0,"Relative precision of param");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTestPrecision=",0,"Relative precision of test");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fCorrelationCoeff=",0,"Multi Correlation coefficient");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_TMatrixTlEdoublegR),G__defined_typename("TMatrixD"),-1,2,"fCorrelationMatrix=",0,"Correlation matrix");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTestCorrelationCoeff=",0,"Multi Correlation coefficient");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TList),-1,-1,2,"fHistograms=",0,"List of histograms");
   G__memvar_setup((void*)0,98,0,0,-1,G__defined_typename("Byte_t"),-1,2,"fHistogramMask=",0,"Bit pattern of hisograms used");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fBinVarX=",0,"Number of bin in independent variables");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fBinVarY=",0,"Number of bin in dependent variables");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TVirtualFitter),-1,-1,2,"fFitter=",0,"! Fit object (MINUIT)");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__HistLN_TMultiDimFitcLcLEMDFPolyType),-1,-1,2,"fPolyType=",0,"Type of polynomials to use");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fShowCorrelation=",0,"print correlation matrix");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsUserFunction=",0,"Flag for user defined function");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsVerbose=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TPolyMarker */
static void G__setup_memvarTPolyMarker(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TPolyMarker));
   { TPolyMarker *p; p=(TPolyMarker*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fN=",0,"number of points");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fLastPoint=",0,"The index of the last filled point");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fX=",0,"[fN] Array of X coordinates");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fY=",0,"[fN] Array of Y coordinates");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_TString),-1,-1,2,"fOption=",0,"options");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TPrincipal */
static void G__setup_memvarTPrincipal(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TPrincipal));
   { TPrincipal *p; p=(TPrincipal*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNumberOfDataPoints=",0,"Number of data points");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNumberOfVariables=",0,"Number of variables");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_TVectorTlEdoublegR),G__defined_typename("TVectorD"),-1,2,"fMeanValues=",0,"Mean value over all data points");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_TVectorTlEdoublegR),G__defined_typename("TVectorD"),-1,2,"fSigmas=",0,"vector of sigmas");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_TMatrixTlEdoublegR),G__defined_typename("TMatrixD"),-1,2,"fCovarianceMatrix=",0,"Covariance matrix");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_TMatrixTlEdoublegR),G__defined_typename("TMatrixD"),-1,2,"fEigenVectors=",0,"Eigenvector matrix of trans");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_TVectorTlEdoublegR),G__defined_typename("TVectorD"),-1,2,"fEigenValues=",0,"Eigenvalue vector of trans");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_TVectorTlEdoublegR),G__defined_typename("TVectorD"),-1,2,"fOffDiagonal=",0,"elements of the tridiagonal");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_TVectorTlEdoublegR),G__defined_typename("TVectorD"),-1,2,"fUserData=",0,"Vector of original data points");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTrace=",0,"Trace of covarience matrix");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TList),-1,-1,2,"fHistograms=",0,"List of histograms");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsNormalised=",0,"Normalize matrix?");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fStoreData=",0,"Should we store input data?");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TProfile3D */
static void G__setup_memvarTProfile3D(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TProfile3D));
   { TProfile3D *p; p=(TProfile3D*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_TArrayD),-1,-1,2,"fBinEntries=",0,"number of entries per bin");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__HistLN_EErrorType),-1,-1,2,"fErrorMode=",0,"Option to compute errors");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTmin=",0,"Lower limit in T (if set)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTmax=",0,"Upper limit in T (if set)");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fScaling=",0,"!True when TProfile3D::Scale is called");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTsumwt=",0,"Total Sum of weight*T");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTsumwt2=",0,"Total Sum of weight*T*T");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_TArrayD),-1,-1,2,"fBinSumw2=",0,"Array of sum of squares of weights per bin ");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-2,2,"fgApproximate=",0,"bin error approximation option");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TSplinePoly */
static void G__setup_memvarTSplinePoly(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TSplinePoly));
   { TSplinePoly *p; p=(TSplinePoly*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fX=",0,"abscissa");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fY=",0,"constant term");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TSplinePoly3 */
static void G__setup_memvarTSplinePoly3(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TSplinePoly3));
   { TSplinePoly3 *p; p=(TSplinePoly3*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fB=",0,"first order expansion coefficient :  fB*1! is the first derivative at x");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fC=",0,"second order expansion coefficient : fC*2! is the second derivative at x");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fD=",0,"third order expansion coefficient :  fD*3! is the third derivative at x");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TSplinePoly5 */
static void G__setup_memvarTSplinePoly5(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TSplinePoly5));
   { TSplinePoly5 *p; p=(TSplinePoly5*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fB=",0,"first order expansion coefficient :  fB*1! is the first derivative at x");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fC=",0,"second order expansion coefficient : fC*2! is the second derivative at x");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fD=",0,"third order expansion coefficient :  fD*3! is the third derivative at x");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fE=",0,"fourth order expansion coefficient : fE*4! is the fourth derivative at x");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fF=",0,"fifth order expansion coefficient :  fF*5! is the fifth derivative at x");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TSpline3 */
static void G__setup_memvarTSpline3(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TSpline3));
   { TSpline3 *p; p=(TSpline3*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TSplinePoly3),-1,-1,2,"fPoly=",0,"[fNp] Array of polynomial terms");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fValBeg=",0,"Initial value of first or second derivative");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fValEnd=",0,"End value of first or second derivative");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fBegCond=",0,"0=no beg cond, 1=first derivative, 2=second derivative");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fEndCond=",0,"0=no end cond, 1=first derivative, 2=second derivative");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TSpline5 */
static void G__setup_memvarTSpline5(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TSpline5));
   { TSpline5 *p; p=(TSpline5*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TSplinePoly5),-1,-1,2,"fPoly=",0,"[fNp] Array of polynomial terms");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TSVDUnfold */
static void G__setup_memvarTSVDUnfold(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TSVDUnfold));
   { TSVDUnfold *p; p=(TSVDUnfold*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNdim=",0,"! Truth and reconstructed dimensions");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fDdim=",0,"! Derivative for curvature matrix");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fNormalize=",0,"! Normalize unfolded spectrum to 1");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fKReg=",0,"! Regularisation parameter");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TH1D),-1,-1,4,"fDHist=",0,"Distribution of d (for checking regularization)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TH1D),-1,-1,4,"fSVHist=",0,"Distribution of singular values");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__HistLN_TH1D),-1,-1,4,"fBdat=",0,"measured distribution (data)");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__HistLN_TH1D),-1,-1,4,"fBini=",0,"reconstructed distribution (MC)");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__HistLN_TH1D),-1,-1,4,"fXini=",0,"truth distribution (MC)");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__HistLN_TH2D),-1,-1,4,"fAdet=",0,"Detector response matrix");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TH1D),-1,-1,4,"fToyhisto=",0,"! Toy MC histogram");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TH2D),-1,-1,4,"fToymat=",0,"! Toy MC detector response matrix");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fToyMode=",0,"! Internal switch for covariance matrix propagation");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fMatToyMode=",0,"! Internal switch for evaluation of statistical uncertainties from response matrix");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TUnfold */
static void G__setup_memvarTUnfold(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TUnfold));
   { TUnfold *p; p=(TUnfold*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TUnfoldcLcLEConstraint),-1,-2,1,G__FastAllocString(2048).Format("kEConstraintNone=%lldLL",(long long)TUnfold::kEConstraintNone).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TUnfoldcLcLEConstraint),-1,-2,1,G__FastAllocString(2048).Format("kEConstraintArea=%lldLL",(long long)TUnfold::kEConstraintArea).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TUnfoldcLcLERegMode),-1,-2,1,G__FastAllocString(2048).Format("kRegModeNone=%lldLL",(long long)TUnfold::kRegModeNone).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TUnfoldcLcLERegMode),-1,-2,1,G__FastAllocString(2048).Format("kRegModeSize=%lldLL",(long long)TUnfold::kRegModeSize).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TUnfoldcLcLERegMode),-1,-2,1,G__FastAllocString(2048).Format("kRegModeDerivative=%lldLL",(long long)TUnfold::kRegModeDerivative).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TUnfoldcLcLERegMode),-1,-2,1,G__FastAllocString(2048).Format("kRegModeCurvature=%lldLL",(long long)TUnfold::kRegModeCurvature).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TUnfoldcLcLERegMode),-1,-2,1,G__FastAllocString(2048).Format("kRegModeMixed=%lldLL",(long long)TUnfold::kRegModeMixed).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TMatrixTSparselEdoublegR),G__defined_typename("TMatrixDSparse"),-1,2,"fA=",0,"Input: matrix");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TMatrixTSparselEdoublegR),G__defined_typename("TMatrixDSparse"),-1,2,"fLsquared=",0,"Input: regularisation conditions squared");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TMatrixTSparselEdoublegR),G__defined_typename("TMatrixDSparse"),-1,2,"fVyy=",0,"Input: covariance matrix for y");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TMatrixTlEdoublegR),G__defined_typename("TMatrixD"),-1,2,"fY=",0,"Input: y");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TMatrixTlEdoublegR),G__defined_typename("TMatrixD"),-1,2,"fX0=",0,"Input: x0");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTauSquared=",0,"Input: regularisation parameter");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fBiasScale=",0,"Input: scale factor for the bias");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_TArrayI),-1,-1,2,"fXToHist=",0,"Input: matrix indices -> histogram bins");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_TArrayI),-1,-1,2,"fHistToX=",0,"Input: histogram bins -> matrix indices");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_TArrayD),-1,-1,2,"fSumOverY=",0,"Input: sum of all columns");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__HistLN_TUnfoldcLcLEConstraint),-1,-1,2,"fConstraint=",0,"Input: type of constraint to use");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__HistLN_TUnfoldcLcLERegMode),-1,-1,2,"fRegMode=",0,"Input: type of regularisation");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TMatrixTlEdoublegR),G__defined_typename("TMatrixD"),-1,4,"fX=",0,"Result: x");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TMatrixTSparselEdoublegR),G__defined_typename("TMatrixDSparse"),-1,4,"fVxx=",0,"Result: covariance matrix on x");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TMatrixTSparselEdoublegR),G__defined_typename("TMatrixDSparse"),-1,4,"fVxxInv=",0,"Result: inverse of covariance matrix on x");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TMatrixTSparselEdoublegR),G__defined_typename("TMatrixDSparse"),-1,4,"fAx=",0,"Result: Ax");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fChi2A=",0,"Result: chi**2 contribution from (y-Ax)V(y-Ax)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fLXsquared=",0,"Result: chi**2 contribution from (x-s*x0)Lsquared(x-s*x0)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fRhoMax=",0,"Result: maximum global correlation");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fRhoAvg=",0,"Result: average global correlation");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNdf=",0,"Result: number of degrees of freedom");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TMatrixTSparselEdoublegR),G__defined_typename("TMatrixDSparse"),-1,4,"fDXDAM[2]=",0,"Result: part of derivative dx_k/dA_ij");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TMatrixTSparselEdoublegR),G__defined_typename("TMatrixDSparse"),-1,4,"fDXDAZ[2]=",0,"Result: part of derivative dx_k/dA_ij");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TMatrixTSparselEdoublegR),G__defined_typename("TMatrixDSparse"),-1,4,"fDXDtauSquared=",0,"Result: derivative dx/dtau");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TMatrixTSparselEdoublegR),G__defined_typename("TMatrixDSparse"),-1,4,"fDXDY=",0,"Result: derivative dx/dy");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TMatrixTSparselEdoublegR),G__defined_typename("TMatrixDSparse"),-1,4,"fEinv=",0,"Result: matrix E^(-1)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TMatrixTSparselEdoublegR),G__defined_typename("TMatrixDSparse"),-1,4,"fE=",0,"Result: matrix E");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TUnfoldcLcLEHistMap),-1,-2,1,G__FastAllocString(2048).Format("kHistMapOutputHoriz=%lldLL",(long long)TUnfold::kHistMapOutputHoriz).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TUnfoldcLcLEHistMap),-1,-2,1,G__FastAllocString(2048).Format("kHistMapOutputVert=%lldLL",(long long)TUnfold::kHistMapOutputVert).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TUnfoldSys */
static void G__setup_memvarTUnfoldSys(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TUnfoldSys));
   { TUnfoldSys *p; p=(TUnfoldSys*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TMatrixTSparselEdoublegR),G__defined_typename("TMatrixDSparse"),-1,2,"fDAinRelSq=",0,"Input: normalized errors from input matrix");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TMatrixTlEdoublegR),G__defined_typename("TMatrixD"),-1,2,"fDAinColRelSq=",0,"Input: normalized column err.sq. (inp.matr.)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TMatrixTlEdoublegR),G__defined_typename("TMatrixD"),-1,2,"fAoutside=",0,"Input: underflow/overflow bins");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TMap),-1,-1,2,"fSysIn=",0,"Input: correlated errors");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TMap),-1,-1,2,"fBgrIn=",0,"Input: size of background sources");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TMap),-1,-1,2,"fBgrErrUncorrIn=",0,"Input: uncorrelated error from bgr sources");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TMap),-1,-1,2,"fBgrErrCorrIn=",0,"Input: background sources correlated error");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDtau=",0,"Input: error on tau");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TMatrixTlEdoublegR),G__defined_typename("TMatrixD"),-1,2,"fYData=",0,"Input: fY prior to bgr subtraction");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TMatrixTSparselEdoublegR),G__defined_typename("TMatrixDSparse"),-1,2,"fVyyData=",0,"Input: error on fY prior to bgr subtraction");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TMatrixTSparselEdoublegR),G__defined_typename("TMatrixDSparse"),-1,2,"fEmatUncorrX=",0,"Result: syst.error from fDA2 on fX");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TMatrixTSparselEdoublegR),G__defined_typename("TMatrixDSparse"),-1,2,"fEmatUncorrAx=",0,"Result: syst.error from fDA2 on fAx");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TMap),-1,-1,2,"fDeltaCorrX=",0,"Result: syst.shift from fSysIn on fX");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TMap),-1,-1,2,"fDeltaCorrAx=",0,"Result: syst.shift from fSysIn on fAx");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TMatrixTSparselEdoublegR),G__defined_typename("TMatrixDSparse"),-1,2,"fDeltaSysTau=",0,"Result: systematic shift from tau");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TUnfoldSyscLcLESysErrMode),-1,-2,1,G__FastAllocString(2048).Format("kSysErrModeMatrix=%lldLL",(long long)TUnfoldSys::kSysErrModeMatrix).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TUnfoldSyscLcLESysErrMode),-1,-2,1,G__FastAllocString(2048).Format("kSysErrModeShift=%lldLL",(long long)TUnfoldSys::kSysErrModeShift).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_TUnfoldSyscLcLESysErrMode),-1,-2,1,G__FastAllocString(2048).Format("kSysErrModeRelative=%lldLL",(long long)TUnfoldSys::kSysErrModeRelative).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TVirtualGraphPainter */
static void G__setup_memvarTVirtualGraphPainter(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_TVirtualGraphPainter));
   { TVirtualGraphPainter *p; p=(TVirtualGraphPainter*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TVirtualGraphPainter),-1,-2,4,"fgPainter=",0,"Pointer to class painter");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* ROOT::Math::WrappedMultiTF1 */
static void G__setup_memvarROOTcLcLMathcLcLWrappedMultiTF1(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_ROOTcLcLMathcLcLWrappedMultiTF1));
   { ROOT::Math::WrappedMultiTF1 *p; p=(ROOT::Math::WrappedMultiTF1*)0x1000; if (p) { }
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fLinear=",0,"flag for linear functions ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TF1),-1,-1,4,"fFunc=",0,"pointer to ROOT function");
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,4,"fDim=",0,"cached value of dimension");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,4,"fParams=",0,"cached vector with parameter values");
   G__memvar_setup((void*)0,100,0,0,-1,-1,-2,4,"fgEps=",0,"epsilon used in derivative calculation h ~ eps |p|");
   }
   G__tag_memvar_reset();
}


   /* ROOT::Math::WrappedTF1 */
static void G__setup_memvarROOTcLcLMathcLcLWrappedTF1(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__HistLN_ROOTcLcLMathcLcLWrappedTF1));
   { ROOT::Math::WrappedTF1 *p; p=(ROOT::Math::WrappedTF1*)0x1000; if (p) { }
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fLinear=",0,"flag for linear functions ");
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fPolynomial=",0,"flag for polynomial functions ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__HistLN_TF1),-1,-1,4,"fFunc=",0,"pointer to ROOT function");
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fX[1]=",0,"! cached vector for x value (needed for TF1::EvalPar signature) ");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__HistLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,4,"fParams=",0,"cached vector with parameter values");
   G__memvar_setup((void*)0,100,0,0,-1,-1,-2,4,"fgEps=",0,"epsilon used in derivative calculation h ~ eps |x|");
   }
   G__tag_memvar_reset();
}

extern "C" void G__cpp_setup_memvarG__Hist() {
}
/***********************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
***********************************************************/

/*********************************************************
* Member function information setup for each class
*********************************************************/
static void G__setup_memfuncFoption_t(void) {
   /* Foption_t */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_Foption_t));
   G__memfunc_setup("Foption_t",946,G__G__Hist_99_0_1, 105, G__get_linked_tagnum(&G__G__HistLN_Foption_t), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("Foption_t", 946, G__G__Hist_99_0_2, (int) ('i'), G__get_linked_tagnum(&G__G__HistLN_Foption_t), -1, 0, 1, 1, 1, 0, "u 'Foption_t' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~Foption_t", 1072, G__G__Hist_99_0_3, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Hist_99_0_4, (int) ('u'), G__get_linked_tagnum(&G__G__HistLN_Foption_t), -1, 1, 1, 1, 1, 0, "u 'Foption_t' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTH1(void) {
   /* TH1 */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TH1));
   G__memfunc_setup("FitOptionsMake",1421,G__G__Hist_100_0_1, 105, -1, G__defined_typename("Int_t"), 0, 2, 3, 1, 0, 
"C - 'Option_t' 10 - option u 'Foption_t' - 1 - Foption", (char*)NULL, (void*) G__func2void( (Int_t (*)(Option_t*, Foption_t&))(&TH1::FitOptionsMake) ), 0);
   G__memfunc_setup("AxisChoice",992,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 4, 8, "C - 'Option_t' 10 - axis", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Build",496,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__HistLN_TH1), -1, 1, 1, 1, 4, 0, "u 'TH1' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("CheckConsistency",1648,(G__InterfaceMethod) NULL, 103, -1, -1, 0, 2, 3, 4, 0, 
"U 'TH1' - 10 - h1 U 'TH1' - 10 - h2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH1",205,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__HistLN_TH1), -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH1",205,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__HistLN_TH1), -1, 0, 5, 1, 2, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx d - 'Double_t' 0 - xlow "
"d - 'Double_t' 0 - xup", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH1",205,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__HistLN_TH1), -1, 0, 4, 1, 2, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx F - 'Float_t' 10 - xbins", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH1",205,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__HistLN_TH1), -1, 0, 4, 1, 2, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx D - 'Double_t' 10 - xbins", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 8, "u 'TObject' - 1 - hnew", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("BufferFill",993,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 2, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - w", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindNewAxisLimits",1714,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 2, 0, 
"U 'TAxis' - 10 - axis d - 'Double_t' 10 - point "
"d - 'Double_t' 1 - newMin d - 'Double_t' 1 - newMax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitiveHelp",1745,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - - 10 - hname "
"C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RecomputeAxisLimits",1979,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 2, 3, 2, 0, 
"u 'TAxis' - 1 - destAxis u 'TAxis' - 11 - anAxis", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SameLimitsAndNBins",1765,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 2, 3, 2, 0, 
"u 'TAxis' - 11 - axis1 u 'TAxis' - 11 - axis2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoIntegral",1001,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 9, 1, 2, 8, 
"i - 'Int_t' 0 - ix1 i - 'Int_t' 0 - ix2 "
"i - 'Int_t' 0 - iy1 i - 'Int_t' 0 - iy2 "
"i - 'Int_t' 0 - iz1 i - 'Int_t' 0 - iz2 "
"d - 'Double_t' 1 - err C - 'Option_t' 10 - opt "
"g - 'Bool_t' 0 'kFALSE' doerr", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TH1",205,G__G__Hist_100_0_17, 105, G__get_linked_tagnum(&G__G__HistLN_TH1), -1, 0, 1, 1, 1, 0, "u 'TH1' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Add",265,G__G__Hist_100_0_18, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TF1' - 0 - h1 d - 'Double_t' 0 '1' c1 "
"C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Add",265,G__G__Hist_100_0_19, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TH1' - 10 - h1 d - 'Double_t' 0 '1' c1", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Add",265,G__G__Hist_100_0_20, 121, -1, -1, 0, 4, 1, 1, 0, 
"U 'TH1' - 10 - h U 'TH1' - 10 - h2 "
"d - 'Double_t' 0 '1' c1 d - 'Double_t' 0 '1' c2", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("AddBinContent",1277,G__G__Hist_100_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddBinContent",1277,G__G__Hist_100_0_22, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - bin d - 'Double_t' 0 - w", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddDirectory",1214,G__G__Hist_100_0_23, 121, -1, -1, 0, 1, 3, 1, 0, "g - 'Bool_t' 0 'kTRUE' add", (char*)NULL, (void*) G__func2void( (void (*)(Bool_t))(&TH1::AddDirectory) ), 0);
   G__memfunc_setup("AddDirectoryStatus",1858,G__G__Hist_100_0_24, 103, -1, G__defined_typename("Bool_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Bool_t (*)())(&TH1::AddDirectoryStatus) ), 0);
   G__memfunc_setup("Browse",626,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TBrowser' - 0 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Chi2Test",742,G__G__Hist_100_0_26, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"U 'TH1' - 10 - h2 C - 'Option_t' 10 '\"UU\"' option "
"D - 'Double_t' 0 '0' res", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Chi2TestX",830,G__G__Hist_100_0_27, 100, -1, G__defined_typename("Double_t"), 0, 6, 1, 1, 8, 
"U 'TH1' - 10 - h2 d - 'Double_t' 1 - chi2 "
"i - 'Int_t' 1 - ndf i - 'Int_t' 1 - igood "
"C - 'Option_t' 10 '\"UU\"' option D - 'Double_t' 0 '0' res", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ComputeIntegral",1555,G__G__Hist_100_0_28, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DirectoryAutoAdd",1623,G__G__Hist_100_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TDirectory' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Divide",597,G__G__Hist_100_0_31, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TF1' - 0 - f1 d - 'Double_t' 0 '1' c1", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Divide",597,G__G__Hist_100_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TH1' - 10 - h1", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Divide",597,G__G__Hist_100_0_33, 121, -1, -1, 0, 5, 1, 1, 0, 
"U 'TH1' - 10 - h1 U 'TH1' - 10 - h2 "
"d - 'Double_t' 0 '1' c1 d - 'Double_t' 0 '1' c2 "
"C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawCopy",809,G__G__Hist_100_0_35, 85, G__get_linked_tagnum(&G__G__HistLN_TH1), -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawNormalized",1443,G__G__Hist_100_0_36, 85, G__get_linked_tagnum(&G__G__HistLN_TH1), -1, 0, 2, 1, 1, 8, 
"C - 'Option_t' 10 '\"\"' option d - 'Double_t' 0 '1' norm", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawPanel",894,G__G__Hist_100_0_37, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("BufferEmpty",1129,G__G__Hist_100_0_38, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 '0' action", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Eval",392,G__G__Hist_100_0_39, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TF1' - 0 - f1 C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FFT",224,G__G__Hist_100_0_41, 85, G__get_linked_tagnum(&G__G__HistLN_TH1), -1, 0, 2, 1, 1, 0, 
"U 'TH1' - 0 - h_output C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Fill",391,G__G__Hist_100_0_42, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Fill",391,G__G__Hist_100_0_43, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - w", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Fill",391,G__G__Hist_100_0_44, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"C - - 10 - name d - 'Double_t' 0 - w", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillN",469,G__G__Hist_100_0_45, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - ntimes D - 'Double_t' 10 - x "
"D - 'Double_t' 10 - w i - 'Int_t' 0 '1' stride", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillN",469,G__G__Hist_100_0_46, 121, -1, -1, 0, 5, 1, 1, 0, 
"i - 'Int_t' 0 - - D - 'Double_t' 10 - - "
"D - 'Double_t' 10 - - D - 'Double_t' 10 - - "
"i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillRandom",1000,G__G__Hist_100_0_47, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - fname i - 'Int_t' 0 '5000' ntimes", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillRandom",1000,G__G__Hist_100_0_48, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TH1' - 0 - h i - 'Int_t' 0 '5000' ntimes", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindBin",666,G__G__Hist_100_0_49, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 '0' y "
"d - 'Double_t' 0 '0' z", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindFixBin",961,G__G__Hist_100_0_50, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 8, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 '0' y "
"d - 'Double_t' 0 '0' z", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindFirstBinAbove",1679,G__G__Hist_100_0_51, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 8, 
"d - 'Double_t' 0 '0' threshold i - 'Int_t' 0 '1' axis", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindLastBinAbove",1563,G__G__Hist_100_0_52, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 8, 
"d - 'Double_t' 0 '0' threshold i - 'Int_t' 0 '1' axis", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindObject",984,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TObject), -1, 0, 1, 1, 1, 8, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindObject",984,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TObject), -1, 0, 1, 1, 1, 8, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Fit",291,G__G__Hist_100_0_55, 117, G__get_linked_tagnum(&G__G__HistLN_TFitResultPtr), -1, 0, 5, 1, 1, 0, 
"C - - 10 - formula C - 'Option_t' 10 '\"\"' option "
"C - 'Option_t' 10 '\"\"' goption d - 'Double_t' 0 '0' xmin "
"d - 'Double_t' 0 '0' xmax", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Fit",291,G__G__Hist_100_0_56, 117, G__get_linked_tagnum(&G__G__HistLN_TFitResultPtr), -1, 0, 5, 1, 1, 0, 
"U 'TF1' - 0 - f1 C - 'Option_t' 10 '\"\"' option "
"C - 'Option_t' 10 '\"\"' goption d - 'Double_t' 0 '0' xmin "
"d - 'Double_t' 0 '0' xmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FitPanel",787,G__G__Hist_100_0_57, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("GetAsymmetry",1259,G__G__Hist_100_0_58, 85, G__get_linked_tagnum(&G__G__HistLN_TH1), -1, 0, 3, 1, 1, 0, 
"U 'TH1' - 0 - h2 d - 'Double_t' 0 '1' c2 "
"d - 'Double_t' 0 '0' dc2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBufferLength",1500,G__G__Hist_100_0_59, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBufferSize",1301,G__G__Hist_100_0_60, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBuffer",890,G__G__Hist_100_0_61, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDefaultBufferSize",2010,G__G__Hist_100_0_62, 105, -1, G__defined_typename("Int_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Int_t (*)())(&TH1::GetDefaultBufferSize) ), 0);
   G__memfunc_setup("GetIntegral",1110,G__G__Hist_100_0_63, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetListOfFunctions",1834,G__G__Hist_100_0_64, 85, G__get_linked_tagnum(&G__G__HistLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNdivisions",1350,G__G__Hist_100_0_65, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"X\"' axis", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetAxisColor",1204,G__G__Hist_100_0_66, 115, -1, G__defined_typename("Color_t"), 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"X\"' axis", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLabelColor",1279,G__G__Hist_100_0_67, 115, -1, G__defined_typename("Color_t"), 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"X\"' axis", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLabelFont",1175,G__G__Hist_100_0_68, 115, -1, G__defined_typename("Style_t"), 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"X\"' axis", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLabelOffset",1383,G__G__Hist_100_0_69, 102, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"X\"' axis", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLabelSize",1179,G__G__Hist_100_0_70, 102, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"X\"' axis", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTitleFont",1209,G__G__Hist_100_0_71, 115, -1, G__defined_typename("Style_t"), 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"X\"' axis", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTitleOffset",1417,G__G__Hist_100_0_72, 102, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"X\"' axis", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTitleSize",1213,G__G__Hist_100_0_73, 102, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"X\"' axis", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTickLength",1293,G__G__Hist_100_0_74, 102, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"X\"' axis", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBarOffset",1180,G__G__Hist_100_0_75, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBarWidth",1077,G__G__Hist_100_0_76, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetContour",1034,G__G__Hist_100_0_77, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "D - 'Double_t' 0 '0' levels", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetContourLevel",1538,G__G__Hist_100_0_78, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - level", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetContourLevelPad",1815,G__G__Hist_100_0_79, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - level", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBin",569,G__G__Hist_100_0_80, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - binx i - 'Int_t' 0 '0' biny "
"i - 'Int_t' 0 '0' binz", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinXYZ",836,G__G__Hist_100_0_81, 121, -1, -1, 0, 4, 1, 1, 8, 
"i - 'Int_t' 0 - binglobal i - 'Int_t' 1 - binx "
"i - 'Int_t' 1 - biny i - 'Int_t' 1 - binz", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinCenter",1178,G__G__Hist_100_0_82, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinContent",1300,G__G__Hist_100_0_83, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinContent",1300,G__G__Hist_100_0_84, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - binx i - 'Int_t' 0 - biny", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinContent",1300,G__G__Hist_100_0_85, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - binx i - 'Int_t' 0 - biny "
"i - 'Int_t' 0 - binz", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinError",1091,G__G__Hist_100_0_86, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinError",1091,G__G__Hist_100_0_87, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - binx i - 'Int_t' 0 - biny", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinError",1091,G__G__Hist_100_0_88, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - binx i - 'Int_t' 0 - biny "
"i - 'Int_t' 0 - binz", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinLowEdge",1248,G__G__Hist_100_0_89, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinWidth",1081,G__G__Hist_100_0_90, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinWithContent",1712,G__G__Hist_100_0_91, 100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"d - 'Double_t' 0 - c i - 'Int_t' 1 - binx "
"i - 'Int_t' 0 '0' firstx i - 'Int_t' 0 '0' lastx "
"d - 'Double_t' 0 '0' maxdiff", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCellContent",1403,G__G__Hist_100_0_92, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - binx i - 'Int_t' 0 - biny", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCellError",1194,G__G__Hist_100_0_93, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - binx i - 'Int_t' 0 - biny", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCenter",897,G__G__Hist_100_0_94, 121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - center", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDefaultSumw2",1475,G__G__Hist_100_0_95, 103, -1, G__defined_typename("Bool_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Bool_t (*)())(&TH1::GetDefaultSumw2) ), 0);
   G__memfunc_setup("GetDirectory",1237,G__G__Hist_100_0_96, 85, G__get_linked_tagnum(&G__G__HistLN_TDirectory), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEntries",1018,G__G__Hist_100_0_97, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEffectiveEntries",1931,G__G__Hist_100_0_98, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetFunction",1126,G__G__Hist_100_0_99, 85, G__get_linked_tagnum(&G__G__HistLN_TF1), -1, 0, 1, 1, 1, 8, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDimension",1222,G__G__Hist_100_0_100, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetKurtosis",1156,G__G__Hist_100_0_101, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 '1' axis", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLowEdge",967,G__G__Hist_100_0_102, 121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - edge", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMaximum",1022,G__G__Hist_100_0_103, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "d - 'Double_t' 0 'FLT_MAX' maxval", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMaximumBin",1303,G__G__Hist_100_0_104, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMaximumBin",1303,G__G__Hist_100_0_105, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 8, 
"i - 'Int_t' 1 - locmax i - 'Int_t' 1 - locmay "
"i - 'Int_t' 1 - locmaz", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMaximumStored",1647,G__G__Hist_100_0_106, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMinimum",1020,G__G__Hist_100_0_107, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "d - 'Double_t' 0 '-FLT_MAX' minval", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMinimumBin",1301,G__G__Hist_100_0_108, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMinimumBin",1301,G__G__Hist_100_0_109, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 8, 
"i - 'Int_t' 1 - locmix i - 'Int_t' 1 - locmiy "
"i - 'Int_t' 1 - locmiz", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMinimumStored",1645,G__G__Hist_100_0_110, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMean",673,G__G__Hist_100_0_111, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 '1' axis", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMeanError",1195,G__G__Hist_100_0_112, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 '1' axis", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNbinsX",882,G__G__Hist_100_0_113, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNbinsY",883,G__G__Hist_100_0_114, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNbinsZ",884,G__G__Hist_100_0_115, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNormFactor",1307,G__G__Hist_100_0_116, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetObjectInfo",1283,(G__InterfaceMethod) NULL,67, -1, -1, 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetOption",921,(G__InterfaceMethod) NULL,67, -1, G__defined_typename("Option_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPainter",1011,G__G__Hist_100_0_119, 85, G__get_linked_tagnum(&G__G__HistLN_TVirtualHistPainter), -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetQuantiles",1238,G__G__Hist_100_0_120, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - nprobSum D - 'Double_t' 0 - q "
"D - 'Double_t' 10 '0' probSum", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRandom",897,G__G__Hist_100_0_121, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetStats",815,G__G__Hist_100_0_122, 121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - stats", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSumOfWeights",1509,G__G__Hist_100_0_123, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSumw2",766,G__G__Hist_100_0_124, 85, G__get_linked_tagnum(&G__G__HistLN_TArrayD), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSumw2",766,G__G__Hist_100_0_125, 85, G__get_linked_tagnum(&G__G__HistLN_TArrayD), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSumw2N",844,G__G__Hist_100_0_126, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRMS",530,G__G__Hist_100_0_127, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 '1' axis", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRMSError",1052,G__G__Hist_100_0_128, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 '1' axis", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSkewness",1139,G__G__Hist_100_0_129, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 '1' axis", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetXaxis",813,G__G__Hist_100_0_130, 85, G__get_linked_tagnum(&G__G__HistLN_TAxis), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetYaxis",814,G__G__Hist_100_0_131, 85, G__get_linked_tagnum(&G__G__HistLN_TAxis), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetZaxis",815,G__G__Hist_100_0_132, 85, G__get_linked_tagnum(&G__G__HistLN_TAxis), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Integral",822,G__G__Hist_100_0_133, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Integral",822,G__G__Hist_100_0_134, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - binx1 i - 'Int_t' 0 - binx2 "
"C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IntegralAndError",1619,G__G__Hist_100_0_135, 100, -1, G__defined_typename("Double_t"), 0, 4, 1, 1, 8, 
"i - 'Int_t' 0 - binx1 i - 'Int_t' 0 - binx2 "
"d - 'Double_t' 1 - err C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Interpolate",1159,G__G__Hist_100_0_136, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Interpolate",1159,G__G__Hist_100_0_137, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Interpolate",1159,G__G__Hist_100_0_138, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsBinOverflow",1321,G__G__Hist_100_0_139, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsBinUnderflow",1419,G__G__Hist_100_0_140, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("KolmogorovTest",1487,G__G__Hist_100_0_141, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"U 'TH1' - 10 - h2 C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LabelsDeflate",1288,G__G__Hist_100_0_142, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"X\"' axis", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LabelsInflate",1302,G__G__Hist_100_0_143, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"X\"' axis", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LabelsOption",1228,G__G__Hist_100_0_144, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - 'Option_t' 10 '\"h\"' option C - 'Option_t' 10 '\"X\"' axis", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Merge",496,G__G__Hist_100_0_145, 110, -1, G__defined_typename("Long64_t"), 0, 1, 1, 1, 0, "U 'TCollection' - 0 - list", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Multiply",864,G__G__Hist_100_0_146, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TF1' - 0 - h1 d - 'Double_t' 0 '1' c1", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Multiply",864,G__G__Hist_100_0_147, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TH1' - 10 - h1", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Multiply",864,G__G__Hist_100_0_148, 121, -1, -1, 0, 5, 1, 1, 0, 
"U 'TH1' - 10 - h1 U 'TH1' - 10 - h2 "
"d - 'Double_t' 0 '1' c1 d - 'Double_t' 0 '1' c2 "
"C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PutStats",840,G__G__Hist_100_0_151, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - stats", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Rebin",496,G__G__Hist_100_0_152, 85, G__get_linked_tagnum(&G__G__HistLN_TH1), -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 '2' ngroup C - - 10 '\"\"' newname "
"D - 'Double_t' 10 '0' xbins", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("RebinAxis",901,G__G__Hist_100_0_153, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - x U 'TAxis' - 0 - axis", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Rebuild",711,G__G__Hist_100_0_154, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RecursiveRemove",1574,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Reset",515,G__G__Hist_100_0_156, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResetStats",1042,G__G__Hist_100_0_157, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Scale",488,G__G__Hist_100_0_159, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 '1' c1 C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetAxisColor",1216,G__G__Hist_100_0_160, 121, -1, -1, 0, 2, 1, 1, 0, 
"s - 'Color_t' 0 '1' color C - 'Option_t' 10 '\"X\"' axis", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetAxisRange",1198,G__G__Hist_100_0_161, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - xmin d - 'Double_t' 0 - xmax "
"C - 'Option_t' 10 '\"X\"' axis", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBarOffset",1192,G__G__Hist_100_0_162, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 '0.25' offset", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBarWidth",1089,G__G__Hist_100_0_163, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 '0.5' width", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinContent",1312,G__G__Hist_100_0_164, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - bin d - 'Double_t' 0 - content", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinContent",1312,G__G__Hist_100_0_165, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - binx i - 'Int_t' 0 - biny "
"d - 'Double_t' 0 - content", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinContent",1312,G__G__Hist_100_0_166, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - binx i - 'Int_t' 0 - biny "
"i - 'Int_t' 0 - binz d - 'Double_t' 0 - content", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinError",1103,G__G__Hist_100_0_167, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - bin d - 'Double_t' 0 - error", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinError",1103,G__G__Hist_100_0_168, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - binx i - 'Int_t' 0 - biny "
"d - 'Double_t' 0 - error", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinError",1103,G__G__Hist_100_0_169, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - binx i - 'Int_t' 0 - biny "
"i - 'Int_t' 0 - binz d - 'Double_t' 0 - error", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBins",696,G__G__Hist_100_0_170, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - nx d - 'Double_t' 0 - xmin "
"d - 'Double_t' 0 - xmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBins",696,G__G__Hist_100_0_171, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - nx D - 'Double_t' 10 - xBins", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBins",696,G__G__Hist_100_0_172, 121, -1, -1, 0, 6, 1, 1, 0, 
"i - 'Int_t' 0 - nx d - 'Double_t' 0 - xmin "
"d - 'Double_t' 0 - xmax i - 'Int_t' 0 - ny "
"d - 'Double_t' 0 - ymin d - 'Double_t' 0 - ymax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBins",696,G__G__Hist_100_0_173, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - nx D - 'Double_t' 10 - xBins "
"i - 'Int_t' 0 - ny D - 'Double_t' 10 - yBins", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBins",696,G__G__Hist_100_0_174, 121, -1, -1, 0, 9, 1, 1, 0, 
"i - 'Int_t' 0 - nx d - 'Double_t' 0 - xmin "
"d - 'Double_t' 0 - xmax i - 'Int_t' 0 - ny "
"d - 'Double_t' 0 - ymin d - 'Double_t' 0 - ymax "
"i - 'Int_t' 0 - nz d - 'Double_t' 0 - zmin "
"d - 'Double_t' 0 - zmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBins",696,G__G__Hist_100_0_175, 121, -1, -1, 0, 6, 1, 1, 0, 
"i - 'Int_t' 0 - nx D - 'Double_t' 10 - xBins "
"i - 'Int_t' 0 - ny D - 'Double_t' 10 - yBins "
"i - 'Int_t' 0 - nz D - 'Double_t' 10 - zBins", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinsLength",1306,G__G__Hist_100_0_176, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '-1' -", "redefined in derived classes", (void*) NULL, 1);
   G__memfunc_setup("SetBuffer",902,G__G__Hist_100_0_177, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - buffersize C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetCellContent",1415,G__G__Hist_100_0_178, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - binx i - 'Int_t' 0 - biny "
"d - 'Double_t' 0 - content", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetCellError",1206,G__G__Hist_100_0_179, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - binx i - 'Int_t' 0 - biny "
"d - 'Double_t' 0 - content", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetContent",1031,G__G__Hist_100_0_180, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - content", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetContour",1046,G__G__Hist_100_0_181, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - nlevels D - 'Double_t' 10 '0' levels", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetContourLevel",1550,G__G__Hist_100_0_182, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - level d - 'Double_t' 0 - value", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDefaultBufferSize",2022,G__G__Hist_100_0_183, 121, -1, -1, 0, 1, 3, 1, 0, "i - 'Int_t' 0 '1000' buffersize", (char*)NULL, (void*) G__func2void( (void (*)(Int_t))(&TH1::SetDefaultBufferSize) ), 0);
   G__memfunc_setup("SetDefaultSumw2",1487,G__G__Hist_100_0_184, 121, -1, -1, 0, 1, 3, 1, 0, "g - 'Bool_t' 0 'kTRUE' sumw2", (char*)NULL, (void*) G__func2void( (void (*)(Bool_t))(&TH1::SetDefaultSumw2) ), 0);
   G__memfunc_setup("SetDirectory",1249,G__G__Hist_100_0_185, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TDirectory' - 0 - dir", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetEntries",1030,G__G__Hist_100_0_186, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetError",822,G__G__Hist_100_0_187, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - error", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLabelColor",1291,G__G__Hist_100_0_188, 121, -1, -1, 0, 2, 1, 1, 0, 
"s - 'Color_t' 0 '1' color C - 'Option_t' 10 '\"X\"' axis", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLabelFont",1187,G__G__Hist_100_0_189, 121, -1, -1, 0, 2, 1, 1, 0, 
"s - 'Style_t' 0 '62' font C - 'Option_t' 10 '\"X\"' axis", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLabelOffset",1395,G__G__Hist_100_0_190, 121, -1, -1, 0, 2, 1, 1, 0, 
"f - 'Float_t' 0 '0.005' offset C - 'Option_t' 10 '\"X\"' axis", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLabelSize",1191,G__G__Hist_100_0_191, 121, -1, -1, 0, 2, 1, 1, 0, 
"f - 'Float_t' 0 '0.02' size C - 'Option_t' 10 '\"X\"' axis", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMaximum",1034,G__G__Hist_100_0_192, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 '-1111' maximum", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetMinimum",1032,G__G__Hist_100_0_193, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 '-1111' minimum", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetName",685,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetNameTitle",1199,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - name C - - 10 - title", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetNdivisions",1362,G__G__Hist_100_0_196, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 '510' n C - 'Option_t' 10 '\"X\"' axis", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetNormFactor",1319,G__G__Hist_100_0_197, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 '1' factor", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetStats",827,G__G__Hist_100_0_198, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' stats", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetOption",933,G__G__Hist_100_0_199, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\" \"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTickLength",1305,G__G__Hist_100_0_200, 121, -1, -1, 0, 2, 1, 1, 0, 
"f - 'Float_t' 0 '0.02' length C - 'Option_t' 10 '\"X\"' axis", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTitleFont",1221,G__G__Hist_100_0_201, 121, -1, -1, 0, 2, 1, 1, 0, 
"s - 'Style_t' 0 '62' font C - 'Option_t' 10 '\"X\"' axis", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTitleOffset",1429,G__G__Hist_100_0_202, 121, -1, -1, 0, 2, 1, 1, 0, 
"f - 'Float_t' 0 '1' offset C - 'Option_t' 10 '\"X\"' axis", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTitleSize",1225,G__G__Hist_100_0_203, 121, -1, -1, 0, 2, 1, 1, 0, 
"f - 'Float_t' 0 '0.02' size C - 'Option_t' 10 '\"X\"' axis", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTitle",814,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - title", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetXTitle",902,G__G__Hist_100_0_205, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - title", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetYTitle",903,G__G__Hist_100_0_206, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - title", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetZTitle",904,G__G__Hist_100_0_207, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - title", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowBackground",1441,G__G__Hist_100_0_208, 85, G__get_linked_tagnum(&G__G__HistLN_TH1), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 '20' niter C - 'Option_t' 10 '\"same\"' option", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("ShowPeaks",917,G__G__Hist_100_0_209, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 '2' sigma C - 'Option_t' 10 '\"\"' option "
"d - 'Double_t' 0 '0.05' threshold", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Smooth",634,G__G__Hist_100_0_210, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 '1' ntimes C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SmoothArray",1145,G__G__Hist_100_0_211, 121, -1, -1, 0, 3, 3, 1, 0, 
"i - 'Int_t' 0 - NN D - 'Double_t' 0 - XX "
"i - 'Int_t' 0 '1' ntimes", (char*)NULL, (void*) G__func2void( (void (*)(Int_t, Double_t*, Int_t))(&TH1::SmoothArray) ), 0);
   G__memfunc_setup("StatOverflows",1379,G__G__Hist_100_0_212, 121, -1, -1, 0, 1, 3, 1, 0, "g - 'Bool_t' 0 'kTRUE' flag", (char*)NULL, (void*) G__func2void( (void (*)(Bool_t))(&TH1::StatOverflows) ), 0);
   G__memfunc_setup("Sumw2",478,G__G__Hist_100_0_213, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UseCurrentStyle",1569,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TransformHisto",1475,G__G__Hist_100_0_215, 85, G__get_linked_tagnum(&G__G__HistLN_TH1), -1, 0, 3, 3, 1, 0, 
"U 'TVirtualFFT' - 0 - fft U 'TH1' - 0 - h_output "
"C - 'Option_t' 10 - option", (char*)NULL, (void*) G__func2void( (TH1* (*)(TVirtualFFT*, TH1*, Option_t*))(&TH1::TransformHisto) ), 0);
   G__memfunc_setup("Class",502,G__G__Hist_100_0_216, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TH1::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_100_0_217, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH1::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_100_0_218, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TH1::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_100_0_219, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TH1::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_100_0_223, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_100_0_224, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH1::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_100_0_225, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TH1::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_100_0_226, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH1::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_100_0_227, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TH1::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TH1", 331, G__G__Hist_100_0_228, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTHnSparse(void) {
   /* THnSparse */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_THnSparse));
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__HistLN_THnSparse), -1, 1, 1, 1, 4, 0, "u 'THnSparse' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("GetChunkSize",1204,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCompactCoord",1502,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__HistLN_THnSparseCompactBinCoord), -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetChunk",793,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__HistLN_THnSparseArrayChunk), -1, 0, 1, 1, 2, 8, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddChunk",770,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__HistLN_THnSparseArrayChunk), -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FillExMap",866,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GenerateArray",1322,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__HistLN_TArray), -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetBinIndexForCurrentBin",2388,(G__InterfaceMethod) NULL, 110, -1, G__defined_typename("Long64_t"), 0, 1, 1, 2, 0, "g - 'Bool_t' 0 - allocate", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Fill",391,(G__InterfaceMethod) NULL, 110, -1, G__defined_typename("Long64_t"), 0, 2, 1, 2, 0, 
"n - 'Long64_t' 0 - bin d - 'Double_t' 0 - w", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CloneEmpty",1024,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__HistLN_THnSparse), -1, 0, 5, 1, 2, 8, 
"C - - 10 - name C - - 10 - title "
"U 'TObjArray' - 10 - axes i - 'Int_t' 0 - chunksize "
"g - 'Bool_t' 0 - keepTargetAxis", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckConsistency",1648,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 2, 8, 
"U 'THnSparse' - 10 - h C - - 10 - tag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsInRange",864,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 2, 8, "I - 'Int_t' 0 - coord", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateHist",1004,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__HistLN_TH1), -1, 0, 4, 1, 2, 8, 
"C - - 10 - name C - - 10 - title "
"U 'TObjArray' - 10 - axes g - 'Bool_t' 0 - keepTargetAxis", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ProjectionAny",1349,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__HistLN_TObject), -1, 0, 4, 1, 2, 8, 
"i - 'Int_t' 0 - ndim I - 'Int_t' 10 - dim "
"g - 'Bool_t' 0 - wantSparse C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PrintBin",806,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 2, 8, 
"n - 'Long64_t' 0 - idx I - 'Int_t' 0 - coord "
"C - 'Option_t' 10 - options", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddInternal",1094,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"U 'THnSparse' - 10 - h d - 'Double_t' 0 - c "
"g - 'Bool_t' 0 - rebinned", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateSparse",1218,G__G__Hist_101_0_20, 85, G__get_linked_tagnum(&G__G__HistLN_THnSparse), -1, 0, 4, 3, 1, 0, 
"C - - 10 - name C - - 10 - title "
"U 'TH1' - 10 - h1 i - 'Int_t' 0 '1024*16' ChunkSize", (char*)NULL, (void*) G__func2void( (THnSparse* (*)(const char*, const char*, const TH1*, Int_t))(&THnSparse::CreateSparse) ), 0);
   G__memfunc_setup("GetNChunks",986,G__G__Hist_101_0_21, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListOfAxes",1282,G__G__Hist_101_0_22, 85, G__get_linked_tagnum(&G__G__HistLN_TObjArray), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAxis",693,G__G__Hist_101_0_23, 85, G__get_linked_tagnum(&G__G__HistLN_TAxis), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - dim", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Fill",391,G__G__Hist_101_0_24, 110, -1, G__defined_typename("Long64_t"), 0, 2, 1, 1, 0, 
"D - 'Double_t' 10 - x d - 'Double_t' 0 '1.' w", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Fill",391,G__G__Hist_101_0_25, 110, -1, G__defined_typename("Long64_t"), 0, 2, 1, 1, 0, 
"C - - 12 - name d - 'Double_t' 0 '1.' w", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Fit",291,G__G__Hist_101_0_26, 117, G__get_linked_tagnum(&G__G__HistLN_TFitResultPtr), -1, 0, 3, 1, 1, 0, 
"U 'TF1' - 0 - f1 C - 'Option_t' 10 '\"\"' option "
"C - 'Option_t' 10 '\"\"' goption", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListOfFunctions",1834,G__G__Hist_101_0_27, 85, G__get_linked_tagnum(&G__G__HistLN_TList), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEntries",1018,G__G__Hist_101_0_28, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetWeightSum",1213,G__G__Hist_101_0_29, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNbins",794,G__G__Hist_101_0_30, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNdimensions",1447,G__G__Hist_101_0_31, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCalculateErrors",1835,G__G__Hist_101_0_32, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CalculateErrors",1547,G__G__Hist_101_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' calc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBin",569,G__G__Hist_101_0_34, 110, -1, G__defined_typename("Long64_t"), 0, 2, 1, 1, 0, 
"I - 'Int_t' 10 - idx g - 'Bool_t' 0 'kTRUE' allocate", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBin",569,G__G__Hist_101_0_35, 110, -1, G__defined_typename("Long64_t"), 0, 2, 1, 1, 0, 
"D - 'Double_t' 10 - x g - 'Bool_t' 0 'kTRUE' allocate", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBin",569,G__G__Hist_101_0_36, 110, -1, G__defined_typename("Long64_t"), 0, 2, 1, 1, 0, 
"C - - 12 - name g - 'Bool_t' 0 'kTRUE' allocate", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBinEdges",1069,G__G__Hist_101_0_37, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - idim D - 'Double_t' 10 - bins", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBinContent",1312,G__G__Hist_101_0_38, 121, -1, -1, 0, 2, 1, 1, 0, 
"I - 'Int_t' 10 - x d - 'Double_t' 0 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBinContent",1312,G__G__Hist_101_0_39, 121, -1, -1, 0, 2, 1, 1, 0, 
"n - 'Long64_t' 0 - bin d - 'Double_t' 0 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBinError",1103,G__G__Hist_101_0_40, 121, -1, -1, 0, 2, 1, 1, 0, 
"I - 'Int_t' 10 - x d - 'Double_t' 0 - e", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBinError",1103,G__G__Hist_101_0_41, 121, -1, -1, 0, 2, 1, 1, 0, 
"n - 'Long64_t' 0 - bin d - 'Double_t' 0 - e", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddBinContent",1277,G__G__Hist_101_0_42, 121, -1, -1, 0, 2, 1, 1, 0, 
"I - 'Int_t' 10 - x d - 'Double_t' 0 '1.' v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddBinContent",1277,G__G__Hist_101_0_43, 121, -1, -1, 0, 2, 1, 1, 0, 
"n - 'Long64_t' 0 - bin d - 'Double_t' 0 '1.' v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEntries",1030,G__G__Hist_101_0_44, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - entries", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTitle",814,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - title", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinContent",1300,G__G__Hist_101_0_46, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "I - 'Int_t' 10 - idx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBinContent",1300,G__G__Hist_101_0_47, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"n - 'Long64_t' 0 - bin I - 'Int_t' 0 '0' idx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBinError",1091,G__G__Hist_101_0_48, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "I - 'Int_t' 10 - idx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBinError",1091,G__G__Hist_101_0_49, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "n - 'Long64_t' 0 - linidx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSparseFractionBins",2128,G__G__Hist_101_0_50, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSparseFractionMem",2019,G__G__Hist_101_0_51, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSumw",716,G__G__Hist_101_0_52, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSumw2",766,G__G__Hist_101_0_53, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSumwx",836,G__G__Hist_101_0_54, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - dim", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSumwx2",886,G__G__Hist_101_0_55, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - dim", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Projection",1053,G__G__Hist_101_0_56, 85, G__get_linked_tagnum(&G__G__HistLN_TH1D), -1, 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - xDim C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Projection",1053,G__G__Hist_101_0_57, 85, G__get_linked_tagnum(&G__G__HistLN_TH2D), -1, 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - yDim i - 'Int_t' 0 - xDim "
"C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Projection",1053,G__G__Hist_101_0_58, 85, G__get_linked_tagnum(&G__G__HistLN_TH3D), -1, 0, 4, 1, 1, 8, 
"i - 'Int_t' 0 - xDim i - 'Int_t' 0 - yDim "
"i - 'Int_t' 0 - zDim C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Projection",1053,G__G__Hist_101_0_59, 85, G__get_linked_tagnum(&G__G__HistLN_THnSparse), -1, 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - ndim I - 'Int_t' 10 - dim "
"C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Rebin",496,G__G__Hist_101_0_60, 85, G__get_linked_tagnum(&G__G__HistLN_THnSparse), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - group", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Rebin",496,G__G__Hist_101_0_61, 85, G__get_linked_tagnum(&G__G__HistLN_THnSparse), -1, 0, 1, 1, 1, 8, "I - 'Int_t' 10 - group", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Merge",496,G__G__Hist_101_0_62, 110, -1, G__defined_typename("Long64_t"), 0, 1, 1, 1, 0, "U 'TCollection' - 0 - list", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Scale",488,G__G__Hist_101_0_63, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Add",265,G__G__Hist_101_0_64, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'THnSparse' - 10 - h d - 'Double_t' 0 '1.' c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Multiply",864,G__G__Hist_101_0_65, 121, -1, -1, 0, 1, 1, 1, 0, "U 'THnSparse' - 10 - h", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Multiply",864,G__G__Hist_101_0_66, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TF1' - 0 - f d - 'Double_t' 0 '1.' c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Divide",597,G__G__Hist_101_0_67, 121, -1, -1, 0, 1, 1, 1, 0, "U 'THnSparse' - 10 - h", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Divide",597,G__G__Hist_101_0_68, 121, -1, -1, 0, 5, 1, 1, 0, 
"U 'THnSparse' - 10 - h1 U 'THnSparse' - 10 - h2 "
"d - 'Double_t' 0 '1.' c1 d - 'Double_t' 0 '1.' c2 "
"C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RebinnedAdd",1072,G__G__Hist_101_0_69, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'THnSparse' - 10 - h d - 'Double_t' 0 '1.' c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Reset",515,G__G__Hist_101_0_70, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Sumw2",478,G__G__Hist_101_0_71, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ComputeIntegral",1555,G__G__Hist_101_0_72, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRandom",897,G__G__Hist_101_0_73, 121, -1, -1, 0, 2, 1, 1, 0, 
"D - 'Double_t' 0 - rand g - 'Bool_t' 0 'kTRUE' subBinRandom", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrintEntries",1255,G__G__Hist_101_0_75, 121, -1, -1, 0, 3, 1, 1, 8, 
"n - 'Long64_t' 0 '0' from n - 'Long64_t' 0 '-1' howmany "
"C - 'Option_t' 10 '0' options", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PrintBin",806,G__G__Hist_101_0_76, 121, -1, -1, 0, 2, 1, 1, 8, 
"I - 'Int_t' 0 - coord C - 'Option_t' 10 - options", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PrintBin",806,G__G__Hist_101_0_77, 121, -1, -1, 0, 2, 1, 1, 8, 
"n - 'Long64_t' 0 - idx C - 'Option_t' 10 - options", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Hist_101_0_78, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&THnSparse::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_101_0_79, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THnSparse::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_101_0_80, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&THnSparse::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_101_0_81, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&THnSparse::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_101_0_85, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_101_0_86, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THnSparse::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_101_0_87, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THnSparse::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_101_0_88, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THnSparse::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_101_0_89, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THnSparse::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~THnSparse", 1014, G__G__Hist_101_0_90, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTF1(void) {
   /* TF1 */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TF1));
   G__memfunc_setup("CreateFromFunctor",1737,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"C - - 10 - name i - 'Int_t' 0 - npar", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateFromCintClass",1900,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 7, 1, 2, 0, 
"C - - 10 - name Y - - 0 - ptr "
"d - 'Double_t' 0 - xmin d - 'Double_t' 0 - xmax "
"i - 'Int_t' 0 - npar C - - 10 - cname "
"C - - 10 - fname", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TF1",203,G__G__Hist_102_0_3, 105, G__get_linked_tagnum(&G__G__HistLN_TF1), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TF1",203,G__G__Hist_102_0_4, 105, G__get_linked_tagnum(&G__G__HistLN_TF1), -1, 0, 4, 1, 1, 0, 
"C - - 10 - name C - - 10 - formula "
"d - 'Double_t' 0 '0' xmin d - 'Double_t' 0 '1' xmax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TF1",203,G__G__Hist_102_0_5, 105, G__get_linked_tagnum(&G__G__HistLN_TF1), -1, 0, 4, 1, 1, 0, 
"C - - 10 - name d - 'Double_t' 0 - xmin "
"d - 'Double_t' 0 - xmax i - 'Int_t' 0 - npar", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TF1",203,G__G__Hist_102_0_6, 105, G__get_linked_tagnum(&G__G__HistLN_TF1), -1, 0, 5, 1, 1, 0, 
"C - - 10 - name Y - - 0 - fcn "
"d - 'Double_t' 0 - xmin d - 'Double_t' 0 - xmax "
"i - 'Int_t' 0 - npar", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TF1",203,G__G__Hist_102_0_7, 105, G__get_linked_tagnum(&G__G__HistLN_TF1), -1, 0, 5, 1, 1, 0, 
"C - - 10 - name u 'ROOT::Math::ParamFunctor' - 0 - f "
"d - 'Double_t' 0 '0' xmin d - 'Double_t' 0 '1' xmax "
"i - 'Int_t' 0 '0' npar", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TF1",203,G__G__Hist_102_0_8, 105, G__get_linked_tagnum(&G__G__HistLN_TF1), -1, 0, 6, 1, 1, 0, 
"C - - 10 - name Y - - 0 - ptr "
"d - 'Double_t' 0 - xmin d - 'Double_t' 0 - xmax "
"i - 'Int_t' 0 - npar C - - 10 - className", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TF1",203,G__G__Hist_102_0_9, 105, G__get_linked_tagnum(&G__G__HistLN_TF1), -1, 0, 8, 1, 1, 0, 
"C - - 10 - name Y - - 0 - ptr "
"Y - - 0 - - d - 'Double_t' 0 - xmin "
"d - 'Double_t' 0 - xmax i - 'Int_t' 0 - npar "
"C - - 10 - className C - - 10 '0' methodName", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TF1",203,G__G__Hist_102_0_10, 105, G__get_linked_tagnum(&G__G__HistLN_TF1), -1, 0, 1, 1, 1, 0, "u 'TF1' - 11 - f1", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Hist_102_0_11, 117, G__get_linked_tagnum(&G__G__HistLN_TF1), -1, 1, 1, 1, 1, 0, "u 'TF1' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Browse",626,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TBrowser' - 0 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TObject' - 1 - f1", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Derivative",1043,G__G__Hist_102_0_14, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"d - 'Double_t' 0 - x D - 'Double_t' 0 '0' params "
"d - 'Double_t' 0 '0.001' epsilon", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Derivative2",1093,G__G__Hist_102_0_15, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"d - 'Double_t' 0 - x D - 'Double_t' 0 '0' params "
"d - 'Double_t' 0 '0.001' epsilon", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Derivative3",1094,G__G__Hist_102_0_16, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"d - 'Double_t' 0 - x D - 'Double_t' 0 '0' params "
"d - 'Double_t' 0 '0.001' epsilon", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DerivativeError",1565,G__G__Hist_102_0_17, 100, -1, G__defined_typename("Double_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Double_t (*)())(&TF1::DerivativeError) ), 0);
   G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawCopy",809,G__G__Hist_102_0_20, 85, G__get_linked_tagnum(&G__G__HistLN_TF1), -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawDerivative",1441,G__G__Hist_102_0_21, 85, G__get_linked_tagnum(&G__G__HistLN_TObject), -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"al\"' option", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("DrawIntegral",1220,G__G__Hist_102_0_22, 85, G__get_linked_tagnum(&G__G__HistLN_TObject), -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"al\"' option", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("DrawF1",517,G__G__Hist_102_0_23, 121, -1, -1, 0, 4, 1, 1, 0, 
"C - - 10 - formula d - 'Double_t' 0 - xmin "
"d - 'Double_t' 0 - xmax C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Eval",392,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 4, 1, 1, 8, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 '0' y "
"d - 'Double_t' 0 '0' z d - 'Double_t' 0 '0' t", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("EvalPar",683,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"D - 'Double_t' 10 - x D - 'Double_t' 10 '0' params", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator()",957,G__G__Hist_102_0_26, 100, -1, G__defined_typename("Double_t"), 0, 4, 1, 1, 8, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 '0' y "
"d - 'Double_t' 0 '0' z d - 'Double_t' 0 '0' t", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator()",957,G__G__Hist_102_0_27, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"D - 'Double_t' 10 - x D - 'Double_t' 10 '0' params", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FixParameter",1224,G__G__Hist_102_0_29, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - ipar d - 'Double_t' 0 - value", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetChisquare",1221,G__G__Hist_102_0_30, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHistogram",1230,G__G__Hist_102_0_31, 85, G__get_linked_tagnum(&G__G__HistLN_TH1), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMaximum",1022,G__G__Hist_102_0_32, 100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"d - 'Double_t' 0 '0' xmin d - 'Double_t' 0 '0' xmax "
"d - 'Double_t' 0 '1.E-10' epsilon i - 'Int_t' 0 '100' maxiter "
"g - 'Bool_t' 0 'false' logx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMinimum",1020,G__G__Hist_102_0_33, 100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"d - 'Double_t' 0 '0' xmin d - 'Double_t' 0 '0' xmax "
"d - 'Double_t' 0 '1.E-10' epsilon i - 'Int_t' 0 '100' maxiter "
"g - 'Bool_t' 0 'false' logx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMaximumX",1110,G__G__Hist_102_0_34, 100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"d - 'Double_t' 0 '0' xmin d - 'Double_t' 0 '0' xmax "
"d - 'Double_t' 0 '1.E-10' epsilon i - 'Int_t' 0 '100' maxiter "
"g - 'Bool_t' 0 'false' logx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMinimumX",1108,G__G__Hist_102_0_35, 100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"d - 'Double_t' 0 '0' xmin d - 'Double_t' 0 '0' xmax "
"d - 'Double_t' 0 '1.E-10' epsilon i - 'Int_t' 0 '100' maxiter "
"g - 'Bool_t' 0 'false' logx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNDF",504,G__G__Hist_102_0_36, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNpx",598,G__G__Hist_102_0_37, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMethodCall",1277,G__G__Hist_102_0_38, 85, G__get_linked_tagnum(&G__G__HistLN_TMethodCall), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNumberFreeParameters",2335,G__G__Hist_102_0_39, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNumberFitPoints",1833,G__G__Hist_102_0_40, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetObjectInfo",1283,(G__InterfaceMethod) NULL,67, -1, -1, 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetParent",906,G__G__Hist_102_0_42, 85, G__get_linked_tagnum(&G__G__HistLN_TObject), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetParError",1101,G__G__Hist_102_0_43, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - ipar", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetParErrors",1216,G__G__Hist_102_0_44, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetParLimits",1205,G__G__Hist_102_0_45, 121, -1, -1, 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - ipar d - 'Double_t' 1 - parmin "
"d - 'Double_t' 1 - parmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetProb",691,G__G__Hist_102_0_46, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetQuantiles",1238,G__G__Hist_102_0_47, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - nprobSum D - 'Double_t' 0 - q "
"D - 'Double_t' 10 - probSum", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRandom",897,G__G__Hist_102_0_48, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRandom",897,G__G__Hist_102_0_49, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - xmin d - 'Double_t' 0 - xmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRange",781,G__G__Hist_102_0_50, 121, -1, -1, 0, 2, 1, 1, 8, 
"d - 'Double_t' 1 - xmin d - 'Double_t' 1 - xmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRange",781,G__G__Hist_102_0_51, 121, -1, -1, 0, 4, 1, 1, 8, 
"d - 'Double_t' 1 - xmin d - 'Double_t' 1 - ymin "
"d - 'Double_t' 1 - xmax d - 'Double_t' 1 - ymax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRange",781,G__G__Hist_102_0_52, 121, -1, -1, 0, 6, 1, 1, 8, 
"d - 'Double_t' 1 - xmin d - 'Double_t' 1 - ymin "
"d - 'Double_t' 1 - zmin d - 'Double_t' 1 - xmax "
"d - 'Double_t' 1 - ymax d - 'Double_t' 1 - zmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSave",687,G__G__Hist_102_0_53, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "D - 'Double_t' 10 - x", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetX",376,G__G__Hist_102_0_54, 100, -1, G__defined_typename("Double_t"), 0, 6, 1, 1, 8, 
"d - 'Double_t' 0 - y d - 'Double_t' 0 '0' xmin "
"d - 'Double_t' 0 '0' xmax d - 'Double_t' 0 '1.E-10' epsilon "
"i - 'Int_t' 0 '100' maxiter g - 'Bool_t' 0 'false' logx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetXmin",700,G__G__Hist_102_0_55, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetXmax",702,G__G__Hist_102_0_56, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetXaxis",813,G__G__Hist_102_0_57, 85, G__get_linked_tagnum(&G__G__HistLN_TAxis), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetYaxis",814,G__G__Hist_102_0_58, 85, G__get_linked_tagnum(&G__G__HistLN_TAxis), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetZaxis",815,G__G__Hist_102_0_59, 85, G__get_linked_tagnum(&G__G__HistLN_TAxis), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GradientPar",1105,G__G__Hist_102_0_60, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - ipar D - 'Double_t' 10 - x "
"d - 'Double_t' 0 '0.01' eps", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GradientPar",1105,G__G__Hist_102_0_61, 121, -1, -1, 0, 3, 1, 1, 0, 
"D - 'Double_t' 10 - x D - 'Double_t' 0 - grad "
"d - 'Double_t' 0 '0.01' eps", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InitArgs",801,G__G__Hist_102_0_62, 121, -1, -1, 0, 2, 1, 1, 0, 
"D - 'Double_t' 10 - x D - 'Double_t' 10 - params", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InitStandardFunctions",2174,G__G__Hist_102_0_63, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TF1::InitStandardFunctions) ), 0);
   G__memfunc_setup("Integral",822,G__G__Hist_102_0_64, 100, -1, G__defined_typename("Double_t"), 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - a d - 'Double_t' 0 - b "
"D - 'Double_t' 10 '0' params d - 'Double_t' 0 '1e-12' epsilon", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Integral",822,G__G__Hist_102_0_65, 100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 0, 
"d - 'Double_t' 0 - ax d - 'Double_t' 0 - bx "
"d - 'Double_t' 0 - ay d - 'Double_t' 0 - by "
"d - 'Double_t' 0 '1e-12' epsilon", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Integral",822,G__G__Hist_102_0_66, 100, -1, G__defined_typename("Double_t"), 0, 7, 1, 1, 0, 
"d - 'Double_t' 0 - ax d - 'Double_t' 0 - bx "
"d - 'Double_t' 0 - ay d - 'Double_t' 0 - by "
"d - 'Double_t' 0 - az d - 'Double_t' 0 - bz "
"d - 'Double_t' 0 '1e-12' epsilon", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IntegralError",1344,G__G__Hist_102_0_67, 100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 0, 
"d - 'Double_t' 0 - a d - 'Double_t' 0 - b "
"D - 'Double_t' 10 '0' params D - 'Double_t' 10 '0' covmat "
"d - 'Double_t' 0 '1e-12' epsilon", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IntegralError",1344,G__G__Hist_102_0_68, 100, -1, G__defined_typename("Double_t"), 0, 6, 1, 1, 0, 
"i - 'Int_t' 0 - n D - 'Double_t' 10 - a "
"D - 'Double_t' 10 - b D - 'Double_t' 10 '0' params "
"D - 'Double_t' 10 '0' covmat d - 'Double_t' 0 '1e-12' epsilon", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IntegralFast",1220,G__G__Hist_102_0_69, 100, -1, G__defined_typename("Double_t"), 0, 7, 1, 1, 0, 
"i - 'Int_t' 0 - num D - 'Double_t' 0 - x "
"D - 'Double_t' 0 - w d - 'Double_t' 0 - a "
"d - 'Double_t' 0 - b D - 'Double_t' 0 '0' params "
"d - 'Double_t' 0 '1e-12' epsilon", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IntegralMultiple",1666,G__G__Hist_102_0_70, 100, -1, G__defined_typename("Double_t"), 0, 9, 1, 1, 0, 
"i - 'Int_t' 0 - n D - 'Double_t' 10 - a "
"D - 'Double_t' 10 - b i - 'Int_t' 0 - minpts "
"i - 'Int_t' 0 - maxpts d - 'Double_t' 0 - epsilon "
"d - 'Double_t' 1 - relerr i - 'Int_t' 1 - nfnevl "
"i - 'Int_t' 1 - ifail", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IntegralMultiple",1666,G__G__Hist_102_0_71, 100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 0, 
"i - 'Int_t' 0 - n D - 'Double_t' 10 - a "
"D - 'Double_t' 10 - b d - 'Double_t' 0 - epsilon "
"d - 'Double_t' 1 - relerr", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsInside",792,G__G__Hist_102_0_72, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "D - 'Double_t' 10 - x", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReleaseParameter",1634,G__G__Hist_102_0_75, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - ipar", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Save",399,G__G__Hist_102_0_76, 121, -1, -1, 0, 6, 1, 1, 0, 
"d - 'Double_t' 0 - xmin d - 'Double_t' 0 - xmax "
"d - 'Double_t' 0 - ymin d - 'Double_t' 0 - ymax "
"d - 'Double_t' 0 - zmin d - 'Double_t' 0 - zmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetChisquare",1233,G__G__Hist_102_0_78, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - chi2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetFitResult",1230,G__G__Hist_102_0_79, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'ROOT::Fit::FitResult' - 11 - result I - 'Int_t' 10 '0' indpar", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMaximum",1034,G__G__Hist_102_0_80, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 '-1111' maximum", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetMinimum",1032,G__G__Hist_102_0_81, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 '-1111' minimum", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetNDF",516,G__G__Hist_102_0_82, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - ndf", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetNumberFitPoints",1845,G__G__Hist_102_0_83, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - npfits", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetNpx",610,G__G__Hist_102_0_84, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '100' npx", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetParError",1113,G__G__Hist_102_0_85, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - ipar d - 'Double_t' 0 - error", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetParErrors",1228,G__G__Hist_102_0_86, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - errors", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetParLimits",1217,G__G__Hist_102_0_87, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - ipar d - 'Double_t' 0 - parmin "
"d - 'Double_t' 0 - parmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetParent",918,G__G__Hist_102_0_88, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 '0' p", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetRange",793,G__G__Hist_102_0_89, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - xmin d - 'Double_t' 0 - xmax", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetRange",793,G__G__Hist_102_0_90, 121, -1, -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - xmin d - 'Double_t' 0 - ymin "
"d - 'Double_t' 0 - xmax d - 'Double_t' 0 - ymax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetRange",793,G__G__Hist_102_0_91, 121, -1, -1, 0, 6, 1, 1, 0, 
"d - 'Double_t' 0 - xmin d - 'Double_t' 0 - ymin "
"d - 'Double_t' 0 - zmin d - 'Double_t' 0 - xmax "
"d - 'Double_t' 0 - ymax d - 'Double_t' 0 - zmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetSavedPoint",1321,G__G__Hist_102_0_92, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - point d - 'Double_t' 0 - value", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTitle",814,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '\"\"' title", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Update",611,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCurrent",1027,G__G__Hist_102_0_95, 85, G__get_linked_tagnum(&G__G__HistLN_TF1), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TF1* (*)())(&TF1::GetCurrent) ), 0);
   G__memfunc_setup("AbsValue",787,G__G__Hist_102_0_96, 121, -1, -1, 0, 1, 3, 1, 0, "g - 'Bool_t' 0 'kTRUE' reject", (char*)NULL, (void*) G__func2void( (void (*)(Bool_t))(&TF1::AbsValue) ), 0);
   G__memfunc_setup("RejectPoint",1127,G__G__Hist_102_0_97, 121, -1, -1, 0, 1, 3, 1, 0, "g - 'Bool_t' 0 'kTRUE' reject", (char*)NULL, (void*) G__func2void( (void (*)(Bool_t))(&TF1::RejectPoint) ), 0);
   G__memfunc_setup("RejectedPoint",1328,G__G__Hist_102_0_98, 103, -1, G__defined_typename("Bool_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Bool_t (*)())(&TF1::RejectedPoint) ), 0);
   G__memfunc_setup("SetCurrent",1039,G__G__Hist_102_0_99, 121, -1, -1, 0, 1, 3, 1, 0, "U 'TF1' - 0 - f1", (char*)NULL, (void*) G__func2void( (void (*)(TF1*))(&TF1::SetCurrent) ), 0);
   G__memfunc_setup("Moment",624,G__G__Hist_102_0_100, 100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 0, 
"d - 'Double_t' 0 - n d - 'Double_t' 0 - a "
"d - 'Double_t' 0 - b D - 'Double_t' 10 '0' params "
"d - 'Double_t' 0 '0.000001' epsilon", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CentralMoment",1337,G__G__Hist_102_0_101, 100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 0, 
"d - 'Double_t' 0 - n d - 'Double_t' 0 - a "
"d - 'Double_t' 0 - b D - 'Double_t' 10 '0' params "
"d - 'Double_t' 0 '0.000001' epsilon", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Mean",385,G__G__Hist_102_0_102, 100, -1, G__defined_typename("Double_t"), 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - a d - 'Double_t' 0 - b "
"D - 'Double_t' 10 '0' params d - 'Double_t' 0 '0.000001' epsilon", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Variance",809,G__G__Hist_102_0_103, 100, -1, G__defined_typename("Double_t"), 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - a d - 'Double_t' 0 - b "
"D - 'Double_t' 10 '0' params d - 'Double_t' 0 '0.000001' epsilon", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CalcGaussLegendreSamplingPoints",3156,G__G__Hist_102_0_104, 121, -1, -1, 0, 4, 3, 1, 0, 
"i - 'Int_t' 0 - num D - 'Double_t' 0 - x "
"D - 'Double_t' 0 - w d - 'Double_t' 0 '3.0e-11' eps", (char*)NULL, (void*) G__func2void( (void (*)(Int_t, Double_t*, Double_t*, Double_t))(&TF1::CalcGaussLegendreSamplingPoints) ), 0);
   G__memfunc_setup("Class",502,G__G__Hist_102_0_105, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TF1::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_102_0_106, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TF1::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_102_0_107, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TF1::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_102_0_108, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TF1::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_102_0_112, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_102_0_113, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TF1::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_102_0_114, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TF1::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_102_0_115, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TF1::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_102_0_116, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TF1::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TF1", 329, G__G__Hist_102_0_117, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTF2(void) {
   /* TF2 */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TF2));
   G__memfunc_setup("TF2",204,G__G__Hist_103_0_1, 105, G__get_linked_tagnum(&G__G__HistLN_TF2), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TF2",204,G__G__Hist_103_0_2, 105, G__get_linked_tagnum(&G__G__HistLN_TF2), -1, 0, 6, 1, 1, 0, 
"C - - 10 - name C - - 10 - formula "
"d - 'Double_t' 0 '0' xmin d - 'Double_t' 0 '1' xmax "
"d - 'Double_t' 0 '0' ymin d - 'Double_t' 0 '1' ymax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TF2",204,G__G__Hist_103_0_3, 105, G__get_linked_tagnum(&G__G__HistLN_TF2), -1, 0, 7, 1, 1, 0, 
"C - - 10 - name Y - - 0 - fcn "
"d - 'Double_t' 0 '0' xmin d - 'Double_t' 0 '1' xmax "
"d - 'Double_t' 0 '0' ymin d - 'Double_t' 0 '1' ymax "
"i - 'Int_t' 0 '0' npar", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TF2",204,G__G__Hist_103_0_4, 105, G__get_linked_tagnum(&G__G__HistLN_TF2), -1, 0, 7, 1, 1, 0, 
"C - - 10 - name u 'ROOT::Math::ParamFunctor' - 0 - f "
"d - 'Double_t' 0 '0' xmin d - 'Double_t' 0 '1' xmax "
"d - 'Double_t' 0 '0' ymin d - 'Double_t' 0 '1' ymax "
"i - 'Int_t' 0 '0' npar", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TF2",204,G__G__Hist_103_0_5, 105, G__get_linked_tagnum(&G__G__HistLN_TF2), -1, 0, 8, 1, 1, 0, 
"C - - 10 - name Y - - 0 - ptr "
"d - 'Double_t' 0 - xmin d - 'Double_t' 0 - xmax "
"d - 'Double_t' 0 - ymin d - 'Double_t' 0 - ymax "
"i - 'Int_t' 0 - npar C - - 10 - className", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TF2",204,G__G__Hist_103_0_6, 105, G__get_linked_tagnum(&G__G__HistLN_TF2), -1, 0, 10, 1, 1, 0, 
"C - - 10 - name Y - - 0 - ptr "
"Y - - 0 - - d - 'Double_t' 0 - xmin "
"d - 'Double_t' 0 - xmax d - 'Double_t' 0 - ymin "
"d - 'Double_t' 0 - ymax i - 'Int_t' 0 - npar "
"C - - 10 - className C - - 10 '0' methodName", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TF2",204,G__G__Hist_103_0_7, 105, G__get_linked_tagnum(&G__G__HistLN_TF2), -1, 0, 1, 1, 1, 0, "u 'TF2' - 11 - f2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Hist_103_0_8, 117, G__get_linked_tagnum(&G__G__HistLN_TF2), -1, 1, 1, 1, 1, 0, "u 'TF2' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TObject' - 1 - f2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawCopy",809,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TF1), -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawDerivative",1441,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TObject), -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"al\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawIntegral",1220,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TObject), -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"al\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawF2",518,G__G__Hist_103_0_15, 121, -1, -1, 0, 6, 1, 1, 0, 
"C - - 10 - formula d - 'Double_t' 0 - xmin "
"d - 'Double_t' 0 - xmax d - 'Double_t' 0 - ymin "
"d - 'Double_t' 0 - ymax C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetContour",1034,G__G__Hist_103_0_17, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "D - 'Double_t' 0 '0' levels", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetContourLevel",1538,G__G__Hist_103_0_18, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - level", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNpy",599,G__G__Hist_103_0_19, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetObjectInfo",1283,(G__InterfaceMethod) NULL,67, -1, -1, 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRandom",897,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRandom",897,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - xmin d - 'Double_t' 0 - xmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRandom2",947,G__G__Hist_103_0_23, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 1 - xrandom d - 'Double_t' 1 - yrandom", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRange",781,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 8, 
"d - 'Double_t' 1 - xmin d - 'Double_t' 1 - xmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRange",781,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 8, 
"d - 'Double_t' 1 - xmin d - 'Double_t' 1 - ymin "
"d - 'Double_t' 1 - xmax d - 'Double_t' 1 - ymax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRange",781,(G__InterfaceMethod) NULL,121, -1, -1, 0, 6, 1, 1, 8, 
"d - 'Double_t' 1 - xmin d - 'Double_t' 1 - ymin "
"d - 'Double_t' 1 - zmin d - 'Double_t' 1 - xmax "
"d - 'Double_t' 1 - ymax d - 'Double_t' 1 - zmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSave",687,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "D - 'Double_t' 10 - x", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMinimumXY",1197,G__G__Hist_103_0_28, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 1 - x d - 'Double_t' 1 - y", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetYmin",701,G__G__Hist_103_0_29, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetYmax",703,G__G__Hist_103_0_30, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Integral",822,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - a d - 'Double_t' 0 - b "
"D - 'Double_t' 10 '0' params d - 'Double_t' 0 '0.000001' epsil", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Integral",822,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 0, 
"d - 'Double_t' 0 - ax d - 'Double_t' 0 - bx "
"d - 'Double_t' 0 - ay d - 'Double_t' 0 - by "
"d - 'Double_t' 0 '0.000001' epsil", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Integral",822,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 7, 1, 1, 0, 
"d - 'Double_t' 0 - ax d - 'Double_t' 0 - bx "
"d - 'Double_t' 0 - ay d - 'Double_t' 0 - by "
"d - 'Double_t' 0 - az d - 'Double_t' 0 - bz "
"d - 'Double_t' 0 '0.000001' epsil", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsInside",792,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "D - 'Double_t' 10 - x", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateHistogram",1538,G__G__Hist_103_0_35, 85, G__get_linked_tagnum(&G__G__HistLN_TH1), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Save",399,(G__InterfaceMethod) NULL,121, -1, -1, 0, 6, 1, 1, 0, 
"d - 'Double_t' 0 - xmin d - 'Double_t' 0 - xmax "
"d - 'Double_t' 0 - ymin d - 'Double_t' 0 - ymax "
"d - 'Double_t' 0 - zmin d - 'Double_t' 0 - zmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetNpy",611,G__G__Hist_103_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '100' npy", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetContour",1046,G__G__Hist_103_0_40, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 '20' nlevels D - 'Double_t' 10 '0' levels", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetContourLevel",1550,G__G__Hist_103_0_41, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - level d - 'Double_t' 0 - value", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetRange",793,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - xmin d - 'Double_t' 0 - xmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetRange",793,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - xmin d - 'Double_t' 0 - ymin "
"d - 'Double_t' 0 - xmax d - 'Double_t' 0 - ymax", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetRange",793,(G__InterfaceMethod) NULL,121, -1, -1, 0, 6, 1, 1, 0, 
"d - 'Double_t' 0 - xmin d - 'Double_t' 0 - ymin "
"d - 'Double_t' 0 - zmin d - 'Double_t' 0 - xmax "
"d - 'Double_t' 0 - ymax d - 'Double_t' 0 - zmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Moment2",674,G__G__Hist_103_0_45, 100, -1, G__defined_typename("Double_t"), 0, 7, 1, 1, 0, 
"d - 'Double_t' 0 - nx d - 'Double_t' 0 - ax "
"d - 'Double_t' 0 - bx d - 'Double_t' 0 - ny "
"d - 'Double_t' 0 - ay d - 'Double_t' 0 - by "
"d - 'Double_t' 0 '0.000001' epsilon", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CentralMoment2",1387,G__G__Hist_103_0_46, 100, -1, G__defined_typename("Double_t"), 0, 7, 1, 1, 0, 
"d - 'Double_t' 0 - nx d - 'Double_t' 0 - ax "
"d - 'Double_t' 0 - bx d - 'Double_t' 0 - ny "
"d - 'Double_t' 0 - ay d - 'Double_t' 0 - by "
"d - 'Double_t' 0 '0.000001' epsilon", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Mean2X",523,G__G__Hist_103_0_47, 100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 0, 
"d - 'Double_t' 0 - ax d - 'Double_t' 0 - bx "
"d - 'Double_t' 0 - ay d - 'Double_t' 0 - by "
"d - 'Double_t' 0 '0.000001' epsilon", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Mean2Y",524,G__G__Hist_103_0_48, 100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 0, 
"d - 'Double_t' 0 - ax d - 'Double_t' 0 - bx "
"d - 'Double_t' 0 - ay d - 'Double_t' 0 - by "
"d - 'Double_t' 0 '0.000001' epsilon", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Variance2X",947,G__G__Hist_103_0_49, 100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 0, 
"d - 'Double_t' 0 - ax d - 'Double_t' 0 - bx "
"d - 'Double_t' 0 - ay d - 'Double_t' 0 - by "
"d - 'Double_t' 0 '0.000001' epsilon", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Variance2Y",948,G__G__Hist_103_0_50, 100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 0, 
"d - 'Double_t' 0 - ax d - 'Double_t' 0 - bx "
"d - 'Double_t' 0 - ay d - 'Double_t' 0 - by "
"d - 'Double_t' 0 '0.000001' epsilon", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Covariance2XY",1246,G__G__Hist_103_0_51, 100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 0, 
"d - 'Double_t' 0 - ax d - 'Double_t' 0 - bx "
"d - 'Double_t' 0 - ay d - 'Double_t' 0 - by "
"d - 'Double_t' 0 '0.000001' epsilon", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Hist_103_0_52, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TF2::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_103_0_53, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TF2::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_103_0_54, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TF2::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_103_0_55, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TF2::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_103_0_59, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_103_0_60, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TF2::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_103_0_61, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TF2::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_103_0_62, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TF2::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_103_0_63, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TF2::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TF2", 330, G__G__Hist_103_0_64, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGraph(void) {
   /* TGraph */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TGraph));
   G__memfunc_setup("SwapValues",1035,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 3, 2, 0, 
"D - 'Double_t' 0 - arr i - 'Int_t' 0 - pos1 "
"i - 'Int_t' 0 - pos2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SwapPoints",1048,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"i - 'Int_t' 0 - pos1 i - 'Int_t' 0 - pos2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Allocate",805,(G__InterfaceMethod) NULL, 68, -1, G__defined_typename("Double_t"), 2, 1, 1, 2, 0, "i - 'Int_t' 0 - newsize", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AllocateArrays",1431,(G__InterfaceMethod) NULL, 68, -1, G__defined_typename("Double_t"), 2, 2, 1, 2, 0, 
"i - 'Int_t' 0 - Narrays i - 'Int_t' 0 - arraySize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CopyPoints",1048,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 2, 0, 
"D - 'Double_t' 2 - newarrays i - 'Int_t' 0 - ibegin "
"i - 'Int_t' 0 - iend i - 'Int_t' 0 - obegin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CopyAndRelease",1391,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 2, 0, 
"D - 'Double_t' 2 - newarrays i - 'Int_t' 0 - ibegin "
"i - 'Int_t' 0 - iend i - 'Int_t' 0 - obegin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CtorAllocate",1213,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ExpandAndCopy",1294,(G__InterfaceMethod) NULL, 68, -1, G__defined_typename("Double_t"), 2, 2, 1, 2, 0, 
"i - 'Int_t' 0 - size i - 'Int_t' 0 - iend", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FillZero",807,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"i - 'Int_t' 0 - begin i - 'Int_t' 0 - end "
"g - 'Bool_t' 0 'kTRUE' from_ctor", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShrinkAndCopy",1309,(G__InterfaceMethod) NULL, 68, -1, G__defined_typename("Double_t"), 2, 2, 1, 2, 0, 
"i - 'Int_t' 0 - size i - 'Int_t' 0 - iend", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGraph",582,G__G__Hist_104_0_11, 105, G__get_linked_tagnum(&G__G__HistLN_TGraph), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGraph",582,G__G__Hist_104_0_12, 105, G__get_linked_tagnum(&G__G__HistLN_TGraph), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGraph",582,G__G__Hist_104_0_13, 105, G__get_linked_tagnum(&G__G__HistLN_TGraph), -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - n I - 'Int_t' 10 - x "
"I - 'Int_t' 10 - y", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGraph",582,G__G__Hist_104_0_14, 105, G__get_linked_tagnum(&G__G__HistLN_TGraph), -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - n F - 'Float_t' 10 - x "
"F - 'Float_t' 10 - y", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGraph",582,G__G__Hist_104_0_15, 105, G__get_linked_tagnum(&G__G__HistLN_TGraph), -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - n D - 'Double_t' 10 - x "
"D - 'Double_t' 10 - y", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGraph",582,G__G__Hist_104_0_16, 105, G__get_linked_tagnum(&G__G__HistLN_TGraph), -1, 0, 1, 1, 1, 0, "u 'TGraph' - 11 - gr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Hist_104_0_17, 117, G__get_linked_tagnum(&G__G__HistLN_TGraph), -1, 1, 1, 1, 1, 0, "u 'TGraph' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGraph",582,G__G__Hist_104_0_18, 105, G__get_linked_tagnum(&G__G__HistLN_TGraph), -1, 0, 2, 1, 1, 0, 
"u 'TVectorT<float>' 'TVectorF' 11 - vx u 'TVectorT<float>' 'TVectorF' 11 - vy", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGraph",582,G__G__Hist_104_0_19, 105, G__get_linked_tagnum(&G__G__HistLN_TGraph), -1, 0, 2, 1, 1, 0, 
"u 'TVectorT<double>' 'TVectorD' 11 - vx u 'TVectorT<double>' 'TVectorD' 11 - vy", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGraph",582,G__G__Hist_104_0_20, 105, G__get_linked_tagnum(&G__G__HistLN_TGraph), -1, 0, 1, 1, 1, 0, "U 'TH1' - 10 - h", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGraph",582,G__G__Hist_104_0_21, 105, G__get_linked_tagnum(&G__G__HistLN_TGraph), -1, 0, 2, 1, 1, 0, 
"U 'TF1' - 10 - f C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGraph",582,G__G__Hist_104_0_22, 105, G__get_linked_tagnum(&G__G__HistLN_TGraph), -1, 0, 3, 1, 1, 0, 
"C - - 10 - filename C - - 10 '\"%lg %lg\"' format "
"C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Apply",518,G__G__Hist_104_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TF1' - 0 - f", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Browse",626,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TBrowser' - 0 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Chisquare",933,G__G__Hist_104_0_25, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "U 'TF1' - 10 - f1", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CompareArg",993,G__G__Hist_104_0_26, 103, -1, G__defined_typename("Bool_t"), 0, 3, 3, 1, 0, 
"U 'TGraph' - 10 - gr i - 'Int_t' 0 - left "
"i - 'Int_t' 0 - right", (char*)NULL, (void*) G__func2void( (Bool_t (*)(const TGraph*, Int_t, Int_t))(&TGraph::CompareArg) ), 0);
   G__memfunc_setup("CompareX",799,G__G__Hist_104_0_27, 103, -1, G__defined_typename("Bool_t"), 0, 3, 3, 1, 0, 
"U 'TGraph' - 10 - gr i - 'Int_t' 0 - left "
"i - 'Int_t' 0 - right", (char*)NULL, (void*) G__func2void( (Bool_t (*)(const TGraph*, Int_t, Int_t))(&TGraph::CompareX) ), 0);
   G__memfunc_setup("CompareY",800,G__G__Hist_104_0_28, 103, -1, G__defined_typename("Bool_t"), 0, 3, 3, 1, 0, 
"U 'TGraph' - 10 - gr i - 'Int_t' 0 - left "
"i - 'Int_t' 0 - right", (char*)NULL, (void*) G__func2void( (Bool_t (*)(const TGraph*, Int_t, Int_t))(&TGraph::CompareY) ), 0);
   G__memfunc_setup("CompareRadius",1327,G__G__Hist_104_0_29, 103, -1, G__defined_typename("Bool_t"), 0, 3, 3, 1, 0, 
"U 'TGraph' - 10 - gr i - 'Int_t' 0 - left "
"i - 'Int_t' 0 - right", (char*)NULL, (void*) G__func2void( (Bool_t (*)(const TGraph*, Int_t, Int_t))(&TGraph::CompareRadius) ), 0);
   G__memfunc_setup("ComputeRange",1226,G__G__Hist_104_0_30, 121, -1, -1, 0, 4, 1, 1, 8, 
"d - 'Double_t' 1 - xmin d - 'Double_t' 1 - ymin "
"d - 'Double_t' 1 - xmax d - 'Double_t' 1 - ymax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' chopt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawGraph",896,G__G__Hist_104_0_33, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - n I - 'Int_t' 10 - x "
"I - 'Int_t' 10 - y C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawGraph",896,G__G__Hist_104_0_34, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - n F - 'Float_t' 10 - x "
"F - 'Float_t' 10 - y C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawGraph",896,G__G__Hist_104_0_35, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - n D - 'Double_t' 10 '0' x "
"D - 'Double_t' 10 '0' y C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawPanel",894,G__G__Hist_104_0_36, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Eval",392,G__G__Hist_104_0_37, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"d - 'Double_t' 0 - x U 'TSpline' - 0 '0' spline "
"C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Expand",608,G__G__Hist_104_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - newsize", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Expand",608,G__G__Hist_104_0_40, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - newsize i - 'Int_t' 0 - step", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindObject",984,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TObject), -1, 0, 1, 1, 1, 8, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindObject",984,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TObject), -1, 0, 1, 1, 1, 8, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Fit",291,G__G__Hist_104_0_43, 117, G__get_linked_tagnum(&G__G__HistLN_TFitResultPtr), -1, 0, 5, 1, 1, 0, 
"C - - 10 - formula C - 'Option_t' 10 '\"\"' option "
"C - 'Option_t' 10 '\"\"' goption d - 'Axis_t' 0 '0' xmin "
"d - 'Axis_t' 0 '0' xmax", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Fit",291,G__G__Hist_104_0_44, 117, G__get_linked_tagnum(&G__G__HistLN_TFitResultPtr), -1, 0, 5, 1, 1, 0, 
"U 'TF1' - 0 - f1 C - 'Option_t' 10 '\"\"' option "
"C - 'Option_t' 10 '\"\"' goption d - 'Axis_t' 0 '0' xmin "
"d - 'Axis_t' 0 '0' xmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FitPanel",787,G__G__Hist_104_0_45, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("GetEditable",1082,G__G__Hist_104_0_46, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFunction",1126,G__G__Hist_104_0_47, 85, G__get_linked_tagnum(&G__G__HistLN_TF1), -1, 0, 1, 1, 1, 8, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHistogram",1230,G__G__Hist_104_0_48, 85, G__get_linked_tagnum(&G__G__HistLN_TH1F), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListOfFunctions",1834,G__G__Hist_104_0_49, 85, G__get_linked_tagnum(&G__G__HistLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCorrelationFactor",2049,G__G__Hist_104_0_50, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCovariance",1307,G__G__Hist_104_0_51, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMean",673,G__G__Hist_104_0_52, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 '1' axis", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRMS",530,G__G__Hist_104_0_53, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 '1' axis", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMaxSize",993,G__G__Hist_104_0_54, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetN",366,G__G__Hist_104_0_55, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetErrorX",898,G__G__Hist_104_0_56, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetErrorY",899,G__G__Hist_104_0_57, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetErrorXhigh",1314,G__G__Hist_104_0_58, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetErrorXlow",1236,G__G__Hist_104_0_59, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetErrorYhigh",1315,G__G__Hist_104_0_60, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetErrorYlow",1237,G__G__Hist_104_0_61, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetX",376,G__G__Hist_104_0_62, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetY",377,G__G__Hist_104_0_63, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEX",445,G__G__Hist_104_0_64, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEY",446,G__G__Hist_104_0_65, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEXhigh",861,G__G__Hist_104_0_66, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEXlow",783,G__G__Hist_104_0_67, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEYhigh",862,G__G__Hist_104_0_68, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEYlow",784,G__G__Hist_104_0_69, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEXlowd",883,G__G__Hist_104_0_70, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEXhighd",961,G__G__Hist_104_0_71, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEYlowd",884,G__G__Hist_104_0_72, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEYhighd",962,G__G__Hist_104_0_73, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMaximum",1022,G__G__Hist_104_0_74, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMinimum",1020,G__G__Hist_104_0_75, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetXaxis",813,G__G__Hist_104_0_76, 85, G__get_linked_tagnum(&G__G__HistLN_TAxis), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetYaxis",814,G__G__Hist_104_0_77, 85, G__get_linked_tagnum(&G__G__HistLN_TAxis), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPoint",810,G__G__Hist_104_0_78, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - i d - 'Double_t' 1 - x "
"d - 'Double_t' 1 - y", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InitExpo",816,G__G__Hist_104_0_79, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 '0' xmin d - 'Double_t' 0 '0' xmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InitGaus",804,G__G__Hist_104_0_80, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 '0' xmin d - 'Double_t' 0 '0' xmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InitPolynom",1154,G__G__Hist_104_0_81, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 '0' xmin d - 'Double_t' 0 '0' xmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InsertPoint",1151,G__G__Hist_104_0_82, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Integral",822,G__G__Hist_104_0_83, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 '0' first i - 'Int_t' 0 '-1' last", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsEditable",982,G__G__Hist_104_0_84, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsInside",792,G__G__Hist_104_0_85, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 8, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LeastSquareFit",1421,G__G__Hist_104_0_86, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - m D - 'Double_t' 0 - a "
"d - 'Double_t' 0 '0' xmin d - 'Double_t' 0 '0' xmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LeastSquareLinearFit",2024,G__G__Hist_104_0_87, 121, -1, -1, 0, 6, 1, 1, 0, 
"i - 'Int_t' 0 - n d - 'Double_t' 1 - a0 "
"d - 'Double_t' 1 - a1 i - 'Int_t' 1 - ifail "
"d - 'Double_t' 0 '0' xmin d - 'Double_t' 0 '0' xmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Merge",496,G__G__Hist_104_0_88, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TCollection' - 0 - list", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' chopt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PaintGraph",1006,G__G__Hist_104_0_90, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - npoints D - 'Double_t' 10 - x "
"D - 'Double_t' 10 - y C - 'Option_t' 10 - chopt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PaintGrapHist",1310,G__G__Hist_104_0_91, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - npoints D - 'Double_t' 10 - x "
"D - 'Double_t' 10 - y C - 'Option_t' 10 - chopt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PaintStats",1035,G__G__Hist_104_0_92, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TF1' - 0 - fit", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' chopt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RecursiveRemove",1574,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RemovePoint",1144,G__G__Hist_104_0_95, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("RemovePoint",1144,G__G__Hist_104_0_96, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - ipoint", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetEditable",1094,G__G__Hist_104_0_98, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' editable", "*TOGGLE* *GETTER=GetEditable", (void*) NULL, 1);
   G__memfunc_setup("SetHistogram",1242,G__G__Hist_104_0_99, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TH1' - 0 - h", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMaximum",1034,G__G__Hist_104_0_100, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 '-1111' maximum", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetMinimum",1032,G__G__Hist_104_0_101, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 '-1111' minimum", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Set",300,G__G__Hist_104_0_102, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPoint",822,G__G__Hist_104_0_103, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - i d - 'Double_t' 0 - x "
"d - 'Double_t' 0 - y", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTitle",814,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '\"\"' title", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Sort",424,G__G__Hist_104_0_105, 121, -1, -1, 0, 4, 1, 1, 0, 
"1 - 'Bool_t (*)(const TGraph*, Int_t, Int_t)' 0 '&TGraph::CompareX' greater g - 'Bool_t' 0 'kTRUE' ascending "
"i - 'Int_t' 0 '0' low i - 'Int_t' 0 '-1111' high", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UseCurrentStyle",1569,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Zero",416,G__G__Hist_104_0_107, 121, -1, -1, 0, 7, 1, 1, 0, 
"i - 'Int_t' 1 - k d - 'Double_t' 0 - AZ "
"d - 'Double_t' 0 - BZ d - 'Double_t' 0 - E2 "
"d - 'Double_t' 1 - X d - 'Double_t' 1 - Y "
"i - 'Int_t' 0 - maxiterations", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Hist_104_0_108, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGraph::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_104_0_109, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGraph::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_104_0_110, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGraph::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_104_0_111, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGraph::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_104_0_115, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_104_0_116, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGraph::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_104_0_117, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGraph::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_104_0_118, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGraph::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_104_0_119, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGraph::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGraph", 708, G__G__Hist_104_0_120, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGraphErrors(void) {
   /* TGraphErrors */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TGraphErrors));
   G__memfunc_setup("SwapPoints",1048,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"i - 'Int_t' 0 - pos1 i - 'Int_t' 0 - pos2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Allocate",805,(G__InterfaceMethod) NULL, 68, -1, G__defined_typename("Double_t"), 2, 1, 1, 2, 0, "i - 'Int_t' 0 - size", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CopyAndRelease",1391,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 2, 0, 
"D - 'Double_t' 2 - newarrays i - 'Int_t' 0 - ibegin "
"i - 'Int_t' 0 - iend i - 'Int_t' 0 - obegin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CopyPoints",1048,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 2, 0, 
"D - 'Double_t' 2 - arrays i - 'Int_t' 0 - ibegin "
"i - 'Int_t' 0 - iend i - 'Int_t' 0 - obegin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CtorAllocate",1213,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FillZero",807,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"i - 'Int_t' 0 - begin i - 'Int_t' 0 - end "
"g - 'Bool_t' 0 'kTRUE' from_ctor", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TGraphErrors",1219,G__G__Hist_105_0_7, 105, G__get_linked_tagnum(&G__G__HistLN_TGraphErrors), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGraphErrors",1219,G__G__Hist_105_0_8, 105, G__get_linked_tagnum(&G__G__HistLN_TGraphErrors), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGraphErrors",1219,G__G__Hist_105_0_9, 105, G__get_linked_tagnum(&G__G__HistLN_TGraphErrors), -1, 0, 5, 1, 1, 0, 
"i - 'Int_t' 0 - n F - 'Float_t' 10 - x "
"F - 'Float_t' 10 - y F - 'Float_t' 10 '0' ex "
"F - 'Float_t' 10 '0' ey", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGraphErrors",1219,G__G__Hist_105_0_10, 105, G__get_linked_tagnum(&G__G__HistLN_TGraphErrors), -1, 0, 5, 1, 1, 0, 
"i - 'Int_t' 0 - n D - 'Double_t' 10 - x "
"D - 'Double_t' 10 - y D - 'Double_t' 10 '0' ex "
"D - 'Double_t' 10 '0' ey", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGraphErrors",1219,G__G__Hist_105_0_11, 105, G__get_linked_tagnum(&G__G__HistLN_TGraphErrors), -1, 0, 4, 1, 1, 0, 
"u 'TVectorT<float>' 'TVectorF' 11 - vx u 'TVectorT<float>' 'TVectorF' 11 - vy "
"u 'TVectorT<float>' 'TVectorF' 11 - vex u 'TVectorT<float>' 'TVectorF' 11 - vey", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGraphErrors",1219,G__G__Hist_105_0_12, 105, G__get_linked_tagnum(&G__G__HistLN_TGraphErrors), -1, 0, 4, 1, 1, 0, 
"u 'TVectorT<double>' 'TVectorD' 11 - vx u 'TVectorT<double>' 'TVectorD' 11 - vy "
"u 'TVectorT<double>' 'TVectorD' 11 - vex u 'TVectorT<double>' 'TVectorD' 11 - vey", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGraphErrors",1219,G__G__Hist_105_0_13, 105, G__get_linked_tagnum(&G__G__HistLN_TGraphErrors), -1, 0, 1, 1, 1, 0, "u 'TGraphErrors' - 11 - gr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Hist_105_0_14, 117, G__get_linked_tagnum(&G__G__HistLN_TGraphErrors), -1, 1, 1, 1, 1, 0, "u 'TGraphErrors' - 11 - gr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGraphErrors",1219,G__G__Hist_105_0_15, 105, G__get_linked_tagnum(&G__G__HistLN_TGraphErrors), -1, 0, 1, 1, 1, 0, "U 'TH1' - 10 - h", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGraphErrors",1219,G__G__Hist_105_0_16, 105, G__get_linked_tagnum(&G__G__HistLN_TGraphErrors), -1, 0, 3, 1, 1, 0, 
"C - - 10 - filename C - - 10 '\"%lg %lg %lg %lg\"' format "
"C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Apply",518,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TF1' - 0 - f", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CalculateScanfFields",2000,G__G__Hist_105_0_18, 105, -1, G__defined_typename("Int_t"), 0, 1, 3, 1, 0, "C - - 10 - fmt", (char*)NULL, (void*) G__func2void( (Int_t (*)(const char*))(&TGraphErrors::CalculateScanfFields) ), 0);
   G__memfunc_setup("ComputeRange",1226,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 8, 
"d - 'Double_t' 1 - xmin d - 'Double_t' 1 - ymin "
"d - 'Double_t' 1 - xmax d - 'Double_t' 1 - ymax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetErrorX",898,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetErrorY",899,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetErrorXhigh",1314,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetErrorXlow",1236,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetErrorYhigh",1315,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetErrorYlow",1237,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEX",445,(G__InterfaceMethod) NULL,68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEY",446,(G__InterfaceMethod) NULL,68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' chopt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPointError",1344,G__G__Hist_105_0_30, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - ex d - 'Double_t' 0 - ey", "*MENU", (void*) NULL, 1);
   G__memfunc_setup("SetPointError",1344,G__G__Hist_105_0_31, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - i d - 'Double_t' 0 - ex "
"d - 'Double_t' 0 - ey", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Hist_105_0_32, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGraphErrors::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_105_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGraphErrors::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_105_0_34, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGraphErrors::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_105_0_35, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGraphErrors::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_105_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_105_0_40, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGraphErrors::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_105_0_41, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGraphErrors::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_105_0_42, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGraphErrors::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_105_0_43, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGraphErrors::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGraphErrors", 1345, G__G__Hist_105_0_44, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGraph2D(void) {
   /* TGraph2D */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TGraph2D));
   G__memfunc_setup("Build",496,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGraph2D",700,G__G__Hist_106_0_2, 105, G__get_linked_tagnum(&G__G__HistLN_TGraph2D), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGraph2D",700,G__G__Hist_106_0_3, 105, G__get_linked_tagnum(&G__G__HistLN_TGraph2D), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGraph2D",700,G__G__Hist_106_0_4, 105, G__get_linked_tagnum(&G__G__HistLN_TGraph2D), -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - n I - 'Int_t' 0 - x "
"I - 'Int_t' 0 - y I - 'Int_t' 0 - z", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGraph2D",700,G__G__Hist_106_0_5, 105, G__get_linked_tagnum(&G__G__HistLN_TGraph2D), -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - n F - 'Float_t' 0 - x "
"F - 'Float_t' 0 - y F - 'Float_t' 0 - z", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGraph2D",700,G__G__Hist_106_0_6, 105, G__get_linked_tagnum(&G__G__HistLN_TGraph2D), -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - n D - 'Double_t' 0 - x "
"D - 'Double_t' 0 - y D - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGraph2D",700,G__G__Hist_106_0_7, 105, G__get_linked_tagnum(&G__G__HistLN_TGraph2D), -1, 0, 1, 1, 1, 0, "U 'TH2' - 0 - h2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGraph2D",700,G__G__Hist_106_0_8, 105, G__get_linked_tagnum(&G__G__HistLN_TGraph2D), -1, 0, 6, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - n D - 'Double_t' 0 - x "
"D - 'Double_t' 0 - y D - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGraph2D",700,G__G__Hist_106_0_9, 105, G__get_linked_tagnum(&G__G__HistLN_TGraph2D), -1, 0, 3, 1, 1, 0, 
"C - - 10 - filename C - - 10 '\"%lg %lg %lg\"' format "
"C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGraph2D",700,G__G__Hist_106_0_10, 105, G__get_linked_tagnum(&G__G__HistLN_TGraph2D), -1, 0, 1, 1, 1, 0, "u 'TGraph2D' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Hist_106_0_11, 117, G__get_linked_tagnum(&G__G__HistLN_TGraph2D), -1, 1, 1, 1, 1, 0, "u 'TGraph2D' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DirectoryAutoAdd",1623,G__G__Hist_106_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TDirectory' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindObject",984,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TObject), -1, 0, 1, 1, 1, 8, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindObject",984,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TObject), -1, 0, 1, 1, 1, 8, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Fit",291,G__G__Hist_106_0_19, 117, G__get_linked_tagnum(&G__G__HistLN_TFitResultPtr), -1, 0, 3, 1, 1, 0, 
"C - - 10 - formula C - 'Option_t' 10 '\"\"' option "
"C - 'Option_t' 10 '\"\"' goption", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Fit",291,G__G__Hist_106_0_20, 117, G__get_linked_tagnum(&G__G__HistLN_TFitResultPtr), -1, 0, 3, 1, 1, 0, 
"U 'TF2' - 0 - f2 C - 'Option_t' 10 '\"\"' option "
"C - 'Option_t' 10 '\"\"' goption", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("FitPanel",787,G__G__Hist_106_0_21, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("GetContourList",1446,G__G__Hist_106_0_22, 85, G__get_linked_tagnum(&G__G__HistLN_TList), -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - contour", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDirectory",1237,G__G__Hist_106_0_23, 85, G__get_linked_tagnum(&G__G__HistLN_TDirectory), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNpx",598,G__G__Hist_106_0_24, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNpy",599,G__G__Hist_106_0_25, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHistogram",1230,G__G__Hist_106_0_26, 85, G__get_linked_tagnum(&G__G__HistLN_TH2D), -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListOfFunctions",1834,G__G__Hist_106_0_27, 85, G__get_linked_tagnum(&G__G__HistLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetErrorX",898,G__G__Hist_106_0_28, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetErrorY",899,G__G__Hist_106_0_29, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetErrorZ",900,G__G__Hist_106_0_30, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMargin",894,G__G__Hist_106_0_31, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetXaxis",813,G__G__Hist_106_0_32, 85, G__get_linked_tagnum(&G__G__HistLN_TAxis), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetYaxis",814,G__G__Hist_106_0_33, 85, G__get_linked_tagnum(&G__G__HistLN_TAxis), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetZaxis",815,G__G__Hist_106_0_34, 85, G__get_linked_tagnum(&G__G__HistLN_TAxis), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetN",366,G__G__Hist_106_0_35, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetX",376,G__G__Hist_106_0_36, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetY",377,G__G__Hist_106_0_37, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetZ",378,G__G__Hist_106_0_38, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEX",445,G__G__Hist_106_0_39, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEY",446,G__G__Hist_106_0_40, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEZ",447,G__G__Hist_106_0_41, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetXmax",702,G__G__Hist_106_0_42, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetXmin",700,G__G__Hist_106_0_43, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetYmax",703,G__G__Hist_106_0_44, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetYmin",701,G__G__Hist_106_0_45, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetZmax",704,G__G__Hist_106_0_46, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetZmin",702,G__G__Hist_106_0_47, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetXmaxE",771,G__G__Hist_106_0_48, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetXminE",769,G__G__Hist_106_0_49, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetYmaxE",772,G__G__Hist_106_0_50, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetYminE",770,G__G__Hist_106_0_51, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetZmaxE",773,G__G__Hist_106_0_52, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetZminE",771,G__G__Hist_106_0_53, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Interpolate",1159,G__G__Hist_106_0_54, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Project",727,G__G__Hist_106_0_56, 85, G__get_linked_tagnum(&G__G__HistLN_TH1), -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"x\"' option", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("RemovePoint",1144,G__G__Hist_106_0_57, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - ipoint", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Set",300,G__G__Hist_106_0_59, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDirectory",1249,G__G__Hist_106_0_60, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TDirectory' - 0 - dir", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetHistogram",1242,G__G__Hist_106_0_61, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TH2' - 0 - h", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMargin",906,G__G__Hist_106_0_62, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 '0.1' m", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetMarginBinsContent",2033,G__G__Hist_106_0_63, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 '0.' z", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetMaximum",1034,G__G__Hist_106_0_64, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 '-1111' maximum", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetMinimum",1032,G__G__Hist_106_0_65, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 '-1111' minimum", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetMaxIter",998,G__G__Hist_106_0_66, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '100000' n", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetName",685,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetNameTitle",1199,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - name C - - 10 - title", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetNpx",610,G__G__Hist_106_0_69, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '40' npx", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetNpy",611,G__G__Hist_106_0_70, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '40' npx", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetPoint",822,G__G__Hist_106_0_71, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - point d - 'Double_t' 0 - x "
"d - 'Double_t' 0 - y d - 'Double_t' 0 - z", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetTitle",814,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '\"\"' title", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Hist_106_0_73, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGraph2D::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_106_0_74, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGraph2D::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_106_0_75, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGraph2D::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_106_0_76, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGraph2D::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_106_0_80, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_106_0_81, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGraph2D::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_106_0_82, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGraph2D::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_106_0_83, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGraph2D::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_106_0_84, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGraph2D::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGraph2D", 826, G__G__Hist_106_0_85, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMultiGraph(void) {
   /* TMultiGraph */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TMultiGraph));
   G__memfunc_setup("TMultiGraph",1105,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__HistLN_TMultiGraph), -1, 0, 1, 1, 2, 0, "u 'TMultiGraph' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__HistLN_TMultiGraph), -1, 1, 1, 1, 2, 0, "u 'TMultiGraph' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMultiGraph",1105,G__G__Hist_107_0_3, 105, G__get_linked_tagnum(&G__G__HistLN_TMultiGraph), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMultiGraph",1105,G__G__Hist_107_0_4, 105, G__get_linked_tagnum(&G__G__HistLN_TMultiGraph), -1, 0, 2, 1, 1, 0, 
"C - - 10 - name C - - 10 - title", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Add",265,G__G__Hist_107_0_5, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGraph' - 0 - graph C - 'Option_t' 10 '\"\"' chopt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Add",265,G__G__Hist_107_0_6, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TMultiGraph' - 0 - multigraph C - 'Option_t' 10 '\"\"' chopt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Browse",626,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TBrowser' - 0 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' chopt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Fit",291,G__G__Hist_107_0_10, 117, G__get_linked_tagnum(&G__G__HistLN_TFitResultPtr), -1, 0, 5, 1, 1, 0, 
"C - - 10 - formula C - 'Option_t' 10 '\"\"' option "
"C - 'Option_t' 10 '\"\"' goption d - 'Axis_t' 0 '0' xmin "
"d - 'Axis_t' 0 '0' xmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Fit",291,G__G__Hist_107_0_11, 117, G__get_linked_tagnum(&G__G__HistLN_TFitResultPtr), -1, 0, 5, 1, 1, 0, 
"U 'TF1' - 0 - f1 C - 'Option_t' 10 '\"\"' option "
"C - 'Option_t' 10 '\"\"' goption d - 'Axis_t' 0 '0' rxmin "
"d - 'Axis_t' 0 '0' rxmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FitPanel",787,G__G__Hist_107_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("GetGraphDrawOption",1817,G__G__Hist_107_0_13, 67, -1, G__defined_typename("Option_t"), 0, 1, 1, 1, 8, "U 'TGraph' - 10 - gr", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LeastSquareLinearFit",2024,G__G__Hist_107_0_14, 121, -1, -1, 0, 6, 1, 1, 0, 
"i - 'Int_t' 0 - ndata d - 'Double_t' 1 - a0 "
"d - 'Double_t' 1 - a1 i - 'Int_t' 1 - ifail "
"d - 'Double_t' 0 - xmin d - 'Double_t' 0 - xmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LeastSquareFit",1421,G__G__Hist_107_0_15, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - m D - 'Double_t' 0 - a "
"d - 'Double_t' 0 - xmin d - 'Double_t' 0 - xmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InitPolynom",1154,G__G__Hist_107_0_16, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - xmin d - 'Double_t' 0 - xmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InitExpo",816,G__G__Hist_107_0_17, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - xmin d - 'Double_t' 0 - xmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InitGaus",804,G__G__Hist_107_0_18, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - xmin d - 'Double_t' 0 - xmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsInside",792,G__G__Hist_107_0_19, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 8, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetHistogram",1230,G__G__Hist_107_0_20, 85, G__get_linked_tagnum(&G__G__HistLN_TH1F), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFunction",1126,G__G__Hist_107_0_21, 85, G__get_linked_tagnum(&G__G__HistLN_TF1), -1, 0, 1, 1, 1, 8, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListOfGraphs",1494,G__G__Hist_107_0_22, 85, G__get_linked_tagnum(&G__G__HistLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListOfFunctions",1834,G__G__Hist_107_0_23, 85, G__get_linked_tagnum(&G__G__HistLN_TList), -1, 0, 0, 1, 1, 0, "", "non const method (create list if empty)", (void*) NULL, 0);
   G__memfunc_setup("GetListOfFunctions",1834,G__G__Hist_107_0_24, 85, G__get_linked_tagnum(&G__G__HistLN_TList), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetXaxis",813,G__G__Hist_107_0_25, 85, G__get_linked_tagnum(&G__G__HistLN_TAxis), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetYaxis",814,G__G__Hist_107_0_26, 85, G__get_linked_tagnum(&G__G__HistLN_TAxis), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' chopt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' chopt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RecursiveRemove",1574,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMaximum",1034,G__G__Hist_107_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 '-1111' maximum", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMinimum",1032,G__G__Hist_107_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 '-1111' minimum", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Hist_107_0_33, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMultiGraph::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_107_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMultiGraph::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_107_0_35, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMultiGraph::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_107_0_36, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMultiGraph::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_107_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_107_0_41, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMultiGraph::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_107_0_42, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMultiGraph::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_107_0_43, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMultiGraph::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_107_0_44, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMultiGraph::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TMultiGraph", 1231, G__G__Hist_107_0_45, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTFitResult(void) {
   /* TFitResult */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TFitResult));
   G__memfunc_setup("TFitResult",1014,G__G__Hist_108_0_1, 105, G__get_linked_tagnum(&G__G__HistLN_TFitResult), -1, 0, 1, 1, 1, 0, "i - - 0 '0' status", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TFitResult",1014,G__G__Hist_108_0_2, 105, G__get_linked_tagnum(&G__G__HistLN_TFitResult), -1, 0, 1, 1, 1, 0, "u 'ROOT::Fit::FitResult' - 11 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCovarianceMatrix",1936,G__G__Hist_108_0_4, 117, G__get_linked_tagnum(&G__G__HistLN_TMatrixTSymlEdoublegR), G__defined_typename("TMatrixDSym"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCorrelationMatrix",2071,G__G__Hist_108_0_5, 117, G__get_linked_tagnum(&G__G__HistLN_TMatrixTSymlEdoublegR), G__defined_typename("TMatrixDSym"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Hist_108_0_6, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TFitResult::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_108_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFitResult::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_108_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TFitResult::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_108_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TFitResult::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_108_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_108_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFitResult::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_108_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TFitResult::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_108_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFitResult::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_108_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TFitResult::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TFitResult", 1014, G__G__Hist_108_0_18, (int) ('i'), G__get_linked_tagnum(&G__G__HistLN_TFitResult), -1, 0, 1, 1, 1, 0, "u 'TFitResult' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TFitResult", 1140, G__G__Hist_108_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Hist_108_0_20, (int) ('u'), G__get_linked_tagnum(&G__G__HistLN_TFitResult), -1, 1, 1, 1, 1, 0, "u 'TFitResult' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTFitResultPtr(void) {
   /* TFitResultPtr */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TFitResultPtr));
   G__memfunc_setup("TFitResultPtr",1324,G__G__Hist_109_0_1, 105, G__get_linked_tagnum(&G__G__HistLN_TFitResultPtr), -1, 0, 1, 1, 1, 0, "i - - 0 '-1' status", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TFitResultPtr",1324,G__G__Hist_109_0_2, 105, G__get_linked_tagnum(&G__G__HistLN_TFitResultPtr), -1, 0, 1, 1, 1, 0, "U 'TFitResult' - 0 - p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TFitResultPtr",1324,G__G__Hist_109_0_3, 105, G__get_linked_tagnum(&G__G__HistLN_TFitResultPtr), -1, 0, 1, 1, 1, 0, "u 'TFitResultPtr' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator int",1239,G__G__Hist_109_0_4, 105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*",918,G__G__Hist_109_0_5, 117, G__get_linked_tagnum(&G__G__HistLN_TFitResult), -1, 1, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator->",983,G__G__Hist_109_0_6, 85, G__get_linked_tagnum(&G__G__HistLN_TFitResult), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Get",288,G__G__Hist_109_0_7, 85, G__get_linked_tagnum(&G__G__HistLN_TFitResult), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Hist_109_0_8, 117, G__get_linked_tagnum(&G__G__HistLN_TFitResultPtr), -1, 1, 1, 1, 1, 0, "u 'TFitResultPtr' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Hist_109_0_9, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TFitResultPtr::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_109_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFitResultPtr::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_109_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TFitResultPtr::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_109_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TFitResultPtr::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Hist_109_0_13, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Hist_109_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Hist_109_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_109_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_109_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFitResultPtr::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_109_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TFitResultPtr::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_109_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFitResultPtr::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_109_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TFitResultPtr::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TFitResultPtr", 1450, G__G__Hist_109_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncROOTcLcLFit(void) {
   /* ROOT::Fit */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_ROOTcLcLFit));
   G__memfunc_setup("UnBinFit",767,G__G__Hist_112_0_1, 117, G__get_linked_tagnum(&G__G__HistLN_TFitResultPtr), -1, 0, 4, 1, 1, 0, 
"U 'ROOT::Fit::UnBinData' - 0 - data U 'TF1' - 0 - f1 "
"u 'Foption_t' - 1 - option u 'ROOT::Math::MinimizerOptions' - 11 - moption", (char*)NULL, (void*) G__func2void( (TFitResultPtr (*)(ROOT::Fit::UnBinData*, TF1*, Foption_t&, const ROOT::Math::MinimizerOptions&))(&ROOT::Fit::UnBinFit) ), 0);
   G__memfunc_setup("FillData",769,G__G__Hist_112_0_2, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'ROOT::Fit::BinData' - 1 - dv U 'TH1' - 10 - hist "
"U 'TF1' - 0 '0' func", (char*)NULL, (void*) G__func2void( (void (*)(ROOT::Fit::BinData&, const TH1*, TF1*))(&ROOT::Fit::FillData) ), 0);
   G__memfunc_setup("FillData",769,G__G__Hist_112_0_3, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'ROOT::Fit::SparseData' - 1 - dv U 'TH1' - 10 - hist "
"U 'TF1' - 0 '0' func", (char*)NULL, (void*) G__func2void( (void (*)(ROOT::Fit::SparseData&, const TH1*, TF1*))(&ROOT::Fit::FillData) ), 0);
   G__memfunc_setup("FillData",769,G__G__Hist_112_0_4, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'ROOT::Fit::SparseData' - 1 - dv U 'THnSparse' - 10 - hist "
"U 'TF1' - 0 '0' func", (char*)NULL, (void*) G__func2void( (void (*)(ROOT::Fit::SparseData&, const THnSparse*, TF1*))(&ROOT::Fit::FillData) ), 0);
   G__memfunc_setup("FillData",769,G__G__Hist_112_0_5, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'ROOT::Fit::BinData' - 1 - dv U 'THnSparse' - 10 - hist "
"U 'TF1' - 0 '0' func", (char*)NULL, (void*) G__func2void( (void (*)(ROOT::Fit::BinData&, const THnSparse*, TF1*))(&ROOT::Fit::FillData) ), 0);
   G__memfunc_setup("FillData",769,G__G__Hist_112_0_6, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'ROOT::Fit::BinData' - 1 - dv U 'TGraph2D' - 10 - gr "
"U 'TF1' - 0 '0' func", (char*)NULL, (void*) G__func2void( (void (*)(ROOT::Fit::BinData&, const TGraph2D*, TF1*))(&ROOT::Fit::FillData) ), 0);
   G__memfunc_setup("FillData",769,G__G__Hist_112_0_7, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'ROOT::Fit::BinData' - 1 - dv U 'TGraph' - 10 - gr "
"U 'TF1' - 0 '0' func", (char*)NULL, (void*) G__func2void( (void (*)(ROOT::Fit::BinData&, const TGraph*, TF1*))(&ROOT::Fit::FillData) ), 0);
   G__memfunc_setup("FillData",769,G__G__Hist_112_0_8, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'ROOT::Fit::BinData' - 1 - dv U 'TMultiGraph' - 10 - gr "
"U 'TF1' - 0 '0' func", (char*)NULL, (void*) G__func2void( (void (*)(ROOT::Fit::BinData&, const TMultiGraph*, TF1*))(&ROOT::Fit::FillData) ), 0);
   G__memfunc_setup("InitExpo",816,G__G__Hist_112_0_9, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'ROOT::Fit::BinData' - 11 - data U 'TF1' - 0 - f1", (char*)NULL, (void*) G__func2void( (void (*)(const ROOT::Fit::BinData&, TF1*))(&ROOT::Fit::InitExpo) ), 0);
   G__memfunc_setup("InitGaus",804,G__G__Hist_112_0_10, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'ROOT::Fit::BinData' - 11 - data U 'TF1' - 0 - f1", (char*)NULL, (void*) G__func2void( (void (*)(const ROOT::Fit::BinData&, TF1*))(&ROOT::Fit::InitGaus) ), 0);
   G__memfunc_setup("Init2DGaus",922,G__G__Hist_112_0_11, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'ROOT::Fit::BinData' - 11 - data U 'TF1' - 0 - f1", (char*)NULL, (void*) G__func2void( (void (*)(const ROOT::Fit::BinData&, TF1*))(&ROOT::Fit::Init2DGaus) ), 0);
   G__memfunc_setup("GetConfidenceIntervals",2246,G__G__Hist_112_0_12, 103, -1, -1, 0, 4, 1, 1, 0, 
"U 'TH1' - 10 - h1 u 'ROOT::Fit::FitResult' - 11 - r "
"U 'TGraphErrors' - 0 - gr d - - 0 '0.95' cl", (char*)NULL, (void*) G__func2void( (bool (*)(const TH1*, const ROOT::Fit::FitResult&, TGraphErrors*, double))(&ROOT::Fit::GetConfidenceIntervals) ), 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncROOTcLcLFitcLcLFitResult(void) {
   /* ROOT::Fit::FitResult */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_ROOTcLcLFitcLcLFitResult));
   G__memfunc_setup("GetCovarianceMatrix<TMatrixDSym>",3152,G__G__Hist_113_0_48, 121, -1, -1, 0, 1, 1, 1, 8, "u 'TMatrixTSym<double>' - 1 - mat", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCorrelationMatrix<TMatrixDSym>",3287,G__G__Hist_113_0_49, 121, -1, -1, 0, 1, 1, 1, 8, "u 'TMatrixTSym<double>' - 1 - mat", (char*)NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTAxis(void) {
   /* TAxis */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TAxis));
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__HistLN_TAxis), -1, 1, 1, 1, 4, 0, "u 'TAxis' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TAxis",489,G__G__Hist_133_0_2, 105, G__get_linked_tagnum(&G__G__HistLN_TAxis), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TAxis",489,G__G__Hist_133_0_3, 105, G__get_linked_tagnum(&G__G__HistLN_TAxis), -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - nbins d - 'Double_t' 0 - xmin "
"d - 'Double_t' 0 - xmax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TAxis",489,G__G__Hist_133_0_4, 105, G__get_linked_tagnum(&G__G__HistLN_TAxis), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - nbins D - 'Double_t' 10 - xbins", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TAxis",489,G__G__Hist_133_0_5, 105, G__get_linked_tagnum(&G__G__HistLN_TAxis), -1, 0, 1, 1, 1, 0, "u 'TAxis' - 11 - axis", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CenterLabels",1204,G__G__Hist_133_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' center", "*TOGGLE* *GETTER=GetCenterLabels", (void*) NULL, 1);
   G__memfunc_setup("CenterTitle",1123,G__G__Hist_133_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' center", "*TOGGLE* *GETTER=GetCenterTitle", (void*) NULL, 1);
   G__memfunc_setup("ChooseTimeFormat",1625,G__G__Hist_133_0_8, 67, -1, -1, 0, 1, 1, 1, 1, "d - 'Double_t' 0 '0' axislength", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TObject' - 1 - axis", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Delete",595,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawClone",895,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TObject), -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindBin",666,G__G__Hist_133_0_14, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindBin",666,G__G__Hist_133_0_15, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - - 10 - label", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindFixBin",961,G__G__Hist_133_0_16, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "d - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinCenter",1178,G__G__Hist_133_0_17, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinCenterLog",1468,G__G__Hist_133_0_18, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinLabel",1049,G__G__Hist_133_0_19, 67, -1, -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBinLowEdge",1248,G__G__Hist_133_0_20, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinUpEdge",1139,G__G__Hist_133_0_21, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinWidth",1081,G__G__Hist_133_0_22, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCenter",897,G__G__Hist_133_0_23, 121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - center", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCenterLabels",1492,G__G__Hist_133_0_24, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCenterTitle",1411,G__G__Hist_133_0_25, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLabels",883,G__G__Hist_133_0_26, 85, G__get_linked_tagnum(&G__G__HistLN_THashList), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLowEdge",967,G__G__Hist_133_0_27, 121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - edge", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMoreLogLabels",1576,G__G__Hist_133_0_28, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNbins",794,G__G__Hist_133_0_29, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNoExponent",1326,G__G__Hist_133_0_30, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDecimals",1090,G__G__Hist_133_0_31, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetParent",906,G__G__Hist_133_0_32, 85, G__get_linked_tagnum(&G__G__HistLN_TObject), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRotateTitle",1425,G__G__Hist_133_0_33, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTicks",798,G__G__Hist_133_0_34, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTimeDisplay",1413,G__G__Hist_133_0_35, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTimeFormat",1304,G__G__Hist_133_0_36, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTimeFormatOnly",1722,G__G__Hist_133_0_37, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTitle",802,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetXbins",804,G__G__Hist_133_0_39, 85, G__get_linked_tagnum(&G__G__HistLN_TArrayD), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFirst",808,G__G__Hist_133_0_40, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLast",692,G__G__Hist_133_0_41, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetXmin",700,G__G__Hist_133_0_42, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetXmax",702,G__G__Hist_133_0_43, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ImportAttributes",1698,G__G__Hist_133_0_44, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TAxis' - 10 - axis", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsVariableBinSize",1686,G__G__Hist_133_0_45, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LabelsOption",1228,G__G__Hist_133_0_46, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"h\"' option", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("RotateTitle",1137,G__G__Hist_133_0_47, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' rotate", "*TOGGLE* *GETTER=GetRotateTitle", (void*) NULL, 1);
   G__memfunc_setup("SaveAttributes",1462,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - - 10 - name "
"C - - 10 - subname", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Set",300,G__G__Hist_133_0_49, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - nbins d - 'Double_t' 0 - xmin "
"d - 'Double_t' 0 - xmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Set",300,G__G__Hist_133_0_50, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - nbins F - 'Float_t' 10 - xbins", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Set",300,G__G__Hist_133_0_51, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - nbins D - 'Double_t' 10 - xbins", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinLabel",1061,G__G__Hist_133_0_52, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - bin C - - 10 - label", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDefaults",1124,G__G__Hist_133_0_53, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDrawOption",1331,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLimits",926,G__G__Hist_133_0_55, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - xmin d - 'Double_t' 0 - xmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMoreLogLabels",1588,G__G__Hist_133_0_56, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' more", "*TOGGLE* *GETTER=GetMoreLogLabels", (void*) NULL, 1);
   G__memfunc_setup("SetNoExponent",1338,G__G__Hist_133_0_57, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' noExponent", "*TOGGLE* *GETTER=GetNoExponent", (void*) NULL, 1);
   G__memfunc_setup("SetDecimals",1102,G__G__Hist_133_0_58, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' dot", "*TOGGLE* *GETTER=GetDecimals", (void*) NULL, 1);
   G__memfunc_setup("SetParent",918,G__G__Hist_133_0_59, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetRange",793,G__G__Hist_133_0_60, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 '0' first i - 'Int_t' 0 '0' last", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetRangeUser",1208,G__G__Hist_133_0_61, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - ufirst d - 'Double_t' 0 - ulast", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetTicks",810,G__G__Hist_133_0_62, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"+\"' option", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetTimeDisplay",1425,G__G__Hist_133_0_63, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - value", "*TOGGLE*", (void*) NULL, 1);
   G__memfunc_setup("SetTimeFormat",1316,G__G__Hist_133_0_64, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '\"\"' format", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetTimeOffset",1314,G__G__Hist_133_0_65, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - toffset C - 'Option_t' 10 '\"local\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UnZoom",616,G__G__Hist_133_0_66, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("ZoomOut",733,G__G__Hist_133_0_67, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 '0' factor d - 'Double_t' 0 '0' offset", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Hist_133_0_68, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TAxis::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_133_0_69, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TAxis::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_133_0_70, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TAxis::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_133_0_71, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TAxis::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_133_0_75, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_133_0_76, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TAxis::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_133_0_77, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TAxis::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_133_0_78, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TAxis::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_133_0_79, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TAxis::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TAxis", 615, G__G__Hist_133_0_80, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTBackCompFitter(void) {
   /* TBackCompFitter */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TBackCompFitter));
   G__memfunc_setup("TBackCompFitter",1474,G__G__Hist_201_0_1, 105, G__get_linked_tagnum(&G__G__HistLN_TBackCompFitter), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TBackCompFitter",1474,G__G__Hist_201_0_2, 105, G__get_linked_tagnum(&G__G__HistLN_TBackCompFitter), -1, 0, 2, 1, 1, 0, 
"u 'auto_ptr<ROOT::Fit::Fitter>' - 0 - fitter u 'auto_ptr<ROOT::Fit::FitData>' - 0 - data", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Chisquare",933,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - npar D - 'Double_t' 0 - params", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExecuteCommand",1426,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"C - - 10 - command D - 'Double_t' 0 - args "
"i - 'Int_t' 0 - nargs", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FixParameter",1224,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - ipar", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetConfidenceIntervals",2246,(G__InterfaceMethod) NULL,121, -1, -1, 0, 5, 1, 1, 0, 
"i - 'Int_t' 0 - n i - 'Int_t' 0 - ndim "
"D - 'Double_t' 10 - x D - 'Double_t' 0 - ci "
"d - 'Double_t' 0 '0.95' cl", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetConfidenceIntervals",2246,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj d - 'Double_t' 0 '0.95' cl", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCovarianceMatrix",1936,(G__InterfaceMethod) NULL,68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCovarianceMatrixElement",2650,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetErrors",925,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 8, 
"i - 'Int_t' 0 - ipar d - 'Double_t' 1 - eplus "
"d - 'Double_t' 1 - eminus d - 'Double_t' 1 - eparab "
"d - 'Double_t' 1 - globcc", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNumberTotalParameters",2465,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNumberFreeParameters",2335,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetParError",1101,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - ipar", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetParameter",1217,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - ipar", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetParameter",1217,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 6, 1, 1, 8, 
"i - 'Int_t' 0 - ipar C - - 0 - name "
"d - 'Double_t' 1 - value d - 'Double_t' 1 - verr "
"d - 'Double_t' 1 - vlow d - 'Double_t' 1 - vhigh", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetParName",964,(G__InterfaceMethod) NULL,67, -1, -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - ipar", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetStats",815,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 8, 
"d - 'Double_t' 1 - amin d - 'Double_t' 1 - edm "
"d - 'Double_t' 1 - errdef i - 'Int_t' 1 - nvpar "
"i - 'Int_t' 1 - nparx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSumLog",887,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsFixed",684,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - ipar", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrintResults",1279,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - level d - 'Double_t' 0 - amin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReleaseParameter",1634,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - ipar", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetFitMethod",1200,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetParameter",1229,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 6, 1, 1, 0, 
"i - 'Int_t' 0 - ipar C - - 10 - parname "
"d - 'Double_t' 0 - value d - 'Double_t' 0 - verr "
"d - 'Double_t' 0 - vlow d - 'Double_t' 0 - vhigh", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetFCN",515,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "1 - 'void (*)(Int_t&, Double_t*, Double_t&f, Double_t*, Int_t) ' 0 - fcn", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetFCN",515,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMethodCall",1289,G__G__Hist_201_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMethodCall' - 0 - m", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetFitConfig",1177,G__G__Hist_201_0_28, 117, G__get_linked_tagnum(&G__G__HistLN_ROOTcLcLFitcLcLFitConfig), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFitResult",1218,G__G__Hist_201_0_29, 117, G__get_linked_tagnum(&G__G__HistLN_ROOTcLcLFitcLcLFitResult), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTFitResult",1302,G__G__Hist_201_0_30, 85, G__get_linked_tagnum(&G__G__HistLN_TFitResult), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFitData",957,G__G__Hist_201_0_31, 117, G__get_linked_tagnum(&G__G__HistLN_ROOTcLcLFitcLcLFitData), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMinimizer",1236,G__G__Hist_201_0_32, 85, G__get_linked_tagnum(&G__G__HistLN_ROOTcLcLMathcLcLMinimizer), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetObjFunction",1409,G__G__Hist_201_0_33, 85, G__get_linked_tagnum(&G__G__HistLN_ROOTcLcLMathcLcLIBaseFunctionMultiDim), G__defined_typename("ROOT::Math::IMultiGenFunction"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Scan",389,G__G__Hist_201_0_34, 103, -1, -1, 0, 4, 1, 1, 0, 
"h - - 0 - ipar U 'TGraph' - 0 - gr "
"d - - 0 '0' xmin d - - 0 '0' xmax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Contour",746,G__G__Hist_201_0_35, 103, -1, -1, 0, 4, 1, 1, 0, 
"h - - 0 - ipar h - - 0 - jpar "
"U 'TGraph' - 0 - gr d - - 0 '0.683' confLevel", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetObjFunction",1421,G__G__Hist_201_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "U 'ROOT::Math::IBaseFunctionMultiDim' 'ROOT::Math::IMultiGenFunction' 0 - f", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReCreateMinimizer",1727,G__G__Hist_201_0_37, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ValidParameterIndex",1929,(G__InterfaceMethod) NULL, 103, -1, -1, 0, 1, 1, 2, 8, "i - - 0 - ipar", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoSetDimension",1413,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Hist_201_0_40, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TBackCompFitter::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_201_0_41, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBackCompFitter::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_201_0_42, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TBackCompFitter::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_201_0_43, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TBackCompFitter::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_201_0_47, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_201_0_48, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBackCompFitter::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_201_0_49, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TBackCompFitter::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_201_0_50, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBackCompFitter::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_201_0_51, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TBackCompFitter::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TBackCompFitter", 1474, G__G__Hist_201_0_52, (int) ('i'), G__get_linked_tagnum(&G__G__HistLN_TBackCompFitter), -1, 0, 1, 1, 1, 0, "u 'TBackCompFitter' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TBackCompFitter", 1600, G__G__Hist_201_0_53, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTBinomialEfficiencyFitter(void) {
   /* TBinomialEfficiencyFitter */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TBinomialEfficiencyFitter));
   G__memfunc_setup("TBinomialEfficiencyFitter",2530,G__G__Hist_205_0_1, 105, G__get_linked_tagnum(&G__G__HistLN_TBinomialEfficiencyFitter), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TBinomialEfficiencyFitter",2530,G__G__Hist_205_0_2, 105, G__get_linked_tagnum(&G__G__HistLN_TBinomialEfficiencyFitter), -1, 0, 2, 1, 1, 0, 
"U 'TH1' - 10 - numerator U 'TH1' - 10 - denominator", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Set",300,G__G__Hist_205_0_3, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TH1' - 10 - numerator U 'TH1' - 10 - denominator", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPrecision",1240,G__G__Hist_205_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - epsilon", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Fit",291,G__G__Hist_205_0_5, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"U 'TF1' - 0 - f1 C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFitter",910,G__G__Hist_205_0_6, 85, G__get_linked_tagnum(&G__G__HistLN_TVirtualFitter), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TVirtualFitter* (*)())(&TBinomialEfficiencyFitter::GetFitter) ), 0);
   G__memfunc_setup("ComputeFCN",948,G__G__Hist_205_0_7, 121, -1, -1, 0, 5, 1, 1, 0, 
"i - 'Int_t' 1 - npar D - 'Double_t' 0 - - "
"d - 'Double_t' 1 - f D - 'Double_t' 0 - par "
"i - 'Int_t' 0 - flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Hist_205_0_8, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TBinomialEfficiencyFitter::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_205_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBinomialEfficiencyFitter::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_205_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TBinomialEfficiencyFitter::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_205_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TBinomialEfficiencyFitter::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_205_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_205_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBinomialEfficiencyFitter::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_205_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TBinomialEfficiencyFitter::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_205_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBinomialEfficiencyFitter::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_205_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TBinomialEfficiencyFitter::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TBinomialEfficiencyFitter", 2530, G__G__Hist_205_0_20, (int) ('i'), 
G__get_linked_tagnum(&G__G__HistLN_TBinomialEfficiencyFitter), -1, 0, 1, 1, 1, 0, "u 'TBinomialEfficiencyFitter' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TBinomialEfficiencyFitter", 2656, G__G__Hist_205_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Hist_205_0_22, (int) ('u'), G__get_linked_tagnum(&G__G__HistLN_TBinomialEfficiencyFitter), -1, 1, 1, 1, 1, 0, "u 'TBinomialEfficiencyFitter' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTConfidenceLevel(void) {
   /* TConfidenceLevel */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TConfidenceLevel));
   G__memfunc_setup("TConfidenceLevel",1594,G__G__Hist_206_0_1, 105, G__get_linked_tagnum(&G__G__HistLN_TConfidenceLevel), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TConfidenceLevel",1594,G__G__Hist_206_0_2, 105, G__get_linked_tagnum(&G__G__HistLN_TConfidenceLevel), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - mc g - - 0 'kTRUE' onesided", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTSD",535,G__G__Hist_206_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - in", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTSB",533,G__G__Hist_206_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - in", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTSS",550,G__G__Hist_206_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - in", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLRS",541,G__G__Hist_206_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - in", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLRB",524,G__G__Hist_206_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - in", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBtot",709,G__G__Hist_206_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - in", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetStot",726,G__G__Hist_206_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - in", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDtot",711,G__G__Hist_206_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - in", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStatistic",1240,G__G__Hist_206_0_11, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetExpectedStatistic_b",2251,G__G__Hist_206_0_13, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 '0' sigma", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetExpectedStatistic_sb",2366,G__G__Hist_206_0_14, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 '0' sigma", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CLb",241,G__G__Hist_206_0_15, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "g - - 0 'kFALSE' use_sMC", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CLsb",356,G__G__Hist_206_0_16, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "g - - 0 'kFALSE' use_sMC", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CLs",258,G__G__Hist_206_0_17, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "g - - 0 'kFALSE' use_sMC", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetExpectedCLb_sb",1655,G__G__Hist_206_0_18, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 '0' sigma", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetExpectedCLb_b",1540,G__G__Hist_206_0_19, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 '0' sigma", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetExpectedCLsb_b",1655,G__G__Hist_206_0_20, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 '0' sigma", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetExpectedCLs_b",1557,G__G__Hist_206_0_21, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 '0' sigma", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAverageCLs",1245,G__G__Hist_206_0_22, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAverageCLsb",1343,G__G__Hist_206_0_23, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Get3sProbability",1607,G__G__Hist_206_0_24, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Get5sProbability",1609,G__G__Hist_206_0_25, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDtot",699,G__G__Hist_206_0_26, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStot",714,G__G__Hist_206_0_27, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBtot",697,G__G__Hist_206_0_28, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Hist_206_0_29, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TConfidenceLevel::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_206_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TConfidenceLevel::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_206_0_31, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TConfidenceLevel::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_206_0_32, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TConfidenceLevel::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_206_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_206_0_37, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TConfidenceLevel::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_206_0_38, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TConfidenceLevel::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_206_0_39, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TConfidenceLevel::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_206_0_40, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TConfidenceLevel::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TConfidenceLevel", 1594, G__G__Hist_206_0_41, (int) ('i'), G__get_linked_tagnum(&G__G__HistLN_TConfidenceLevel), -1, 0, 1, 1, 1, 0, "u 'TConfidenceLevel' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TConfidenceLevel", 1720, G__G__Hist_206_0_42, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Hist_206_0_43, (int) ('u'), G__get_linked_tagnum(&G__G__HistLN_TConfidenceLevel), -1, 1, 1, 1, 1, 0, "u 'TConfidenceLevel' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGraphAsymmErrors(void) {
   /* TGraphAsymmErrors */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TGraphAsymmErrors));
   G__memfunc_setup("SwapPoints",1048,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"i - 'Int_t' 0 - pos1 i - 'Int_t' 0 - pos2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Allocate",805,(G__InterfaceMethod) NULL, 68, -1, G__defined_typename("Double_t"), 2, 1, 1, 2, 0, "i - 'Int_t' 0 - size", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CopyAndRelease",1391,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 2, 0, 
"D - 'Double_t' 2 - newarrays i - 'Int_t' 0 - ibegin "
"i - 'Int_t' 0 - iend i - 'Int_t' 0 - obegin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CopyPoints",1048,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 2, 0, 
"D - 'Double_t' 2 - arrays i - 'Int_t' 0 - ibegin "
"i - 'Int_t' 0 - iend i - 'Int_t' 0 - obegin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CtorAllocate",1213,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FillZero",807,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"i - 'Int_t' 0 - begin i - 'Int_t' 0 - end "
"g - 'Bool_t' 0 'kTRUE' from_ctor", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TGraphAsymmErrors",1738,G__G__Hist_213_0_7, 105, G__get_linked_tagnum(&G__G__HistLN_TGraphAsymmErrors), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGraphAsymmErrors",1738,G__G__Hist_213_0_8, 105, G__get_linked_tagnum(&G__G__HistLN_TGraphAsymmErrors), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGraphAsymmErrors",1738,G__G__Hist_213_0_9, 105, G__get_linked_tagnum(&G__G__HistLN_TGraphAsymmErrors), -1, 0, 7, 1, 1, 0, 
"i - 'Int_t' 0 - n F - 'Float_t' 10 - x "
"F - 'Float_t' 10 - y F - 'Float_t' 10 '0' exl "
"F - 'Float_t' 10 '0' exh F - 'Float_t' 10 '0' eyl "
"F - 'Float_t' 10 '0' eyh", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGraphAsymmErrors",1738,G__G__Hist_213_0_10, 105, G__get_linked_tagnum(&G__G__HistLN_TGraphAsymmErrors), -1, 0, 7, 1, 1, 0, 
"i - 'Int_t' 0 - n D - 'Double_t' 10 - x "
"D - 'Double_t' 10 - y D - 'Double_t' 10 '0' exl "
"D - 'Double_t' 10 '0' exh D - 'Double_t' 10 '0' eyl "
"D - 'Double_t' 10 '0' eyh", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGraphAsymmErrors",1738,G__G__Hist_213_0_11, 105, G__get_linked_tagnum(&G__G__HistLN_TGraphAsymmErrors), -1, 0, 6, 1, 1, 0, 
"u 'TVectorT<float>' 'TVectorF' 11 - vx u 'TVectorT<float>' 'TVectorF' 11 - vy "
"u 'TVectorT<float>' 'TVectorF' 11 - vexl u 'TVectorT<float>' 'TVectorF' 11 - vexh "
"u 'TVectorT<float>' 'TVectorF' 11 - veyl u 'TVectorT<float>' 'TVectorF' 11 - veyh", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGraphAsymmErrors",1738,G__G__Hist_213_0_12, 105, G__get_linked_tagnum(&G__G__HistLN_TGraphAsymmErrors), -1, 0, 6, 1, 1, 0, 
"u 'TVectorT<double>' 'TVectorD' 11 - vx u 'TVectorT<double>' 'TVectorD' 11 - vy "
"u 'TVectorT<double>' 'TVectorD' 11 - vexl u 'TVectorT<double>' 'TVectorD' 11 - vexh "
"u 'TVectorT<double>' 'TVectorD' 11 - veyl u 'TVectorT<double>' 'TVectorD' 11 - veyh", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGraphAsymmErrors",1738,G__G__Hist_213_0_13, 105, G__get_linked_tagnum(&G__G__HistLN_TGraphAsymmErrors), -1, 0, 1, 1, 1, 0, "u 'TGraphAsymmErrors' - 11 - gr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Hist_213_0_14, 117, G__get_linked_tagnum(&G__G__HistLN_TGraphAsymmErrors), -1, 1, 1, 1, 1, 0, "u 'TGraphAsymmErrors' - 11 - gr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGraphAsymmErrors",1738,G__G__Hist_213_0_15, 105, G__get_linked_tagnum(&G__G__HistLN_TGraphAsymmErrors), -1, 0, 1, 1, 1, 0, "U 'TH1' - 10 - h", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGraphAsymmErrors",1738,G__G__Hist_213_0_16, 105, G__get_linked_tagnum(&G__G__HistLN_TGraphAsymmErrors), -1, 0, 3, 1, 1, 0, 
"U 'TH1' - 10 - pass U 'TH1' - 10 - total "
"C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Apply",518,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TF1' - 0 - f", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("BayesDivide",1097,G__G__Hist_213_0_18, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TH1' - 10 - pass U 'TH1' - 10 - total "
"C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Divide",597,G__G__Hist_213_0_19, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TH1' - 10 - pass U 'TH1' - 10 - total "
"C - 'Option_t' 10 '\"cp\"' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ComputeRange",1226,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 8, 
"d - 'Double_t' 1 - xmin d - 'Double_t' 1 - ymin "
"d - 'Double_t' 1 - xmax d - 'Double_t' 1 - ymax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetErrorX",898,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetErrorY",899,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetErrorXlow",1236,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetErrorXhigh",1314,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetErrorYlow",1237,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetErrorYhigh",1315,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEXlow",783,(G__InterfaceMethod) NULL,68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEXhigh",861,(G__InterfaceMethod) NULL,68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEYlow",784,(G__InterfaceMethod) NULL,68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEYhigh",862,(G__InterfaceMethod) NULL,68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' chopt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPointError",1344,G__G__Hist_213_0_33, 121, -1, -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - exl d - 'Double_t' 0 - exh "
"d - 'Double_t' 0 - eyl d - 'Double_t' 0 - eyh", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetPointError",1344,G__G__Hist_213_0_34, 121, -1, -1, 0, 5, 1, 1, 0, 
"i - 'Int_t' 0 - i d - 'Double_t' 0 - exl "
"d - 'Double_t' 0 - exh d - 'Double_t' 0 - eyl "
"d - 'Double_t' 0 - eyh", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPointEXlow",1317,G__G__Hist_213_0_35, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - i d - 'Double_t' 0 - exl", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPointEXhigh",1395,G__G__Hist_213_0_36, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - i d - 'Double_t' 0 - exh", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPointEYlow",1318,G__G__Hist_213_0_37, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - i d - 'Double_t' 0 - eyl", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPointEYhigh",1396,G__G__Hist_213_0_38, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - i d - 'Double_t' 0 - eyh", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Hist_213_0_39, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGraphAsymmErrors::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_213_0_40, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGraphAsymmErrors::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_213_0_41, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGraphAsymmErrors::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_213_0_42, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGraphAsymmErrors::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_213_0_46, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_213_0_47, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGraphAsymmErrors::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_213_0_48, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGraphAsymmErrors::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_213_0_49, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGraphAsymmErrors::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_213_0_50, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGraphAsymmErrors::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGraphAsymmErrors", 1864, G__G__Hist_213_0_51, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTH2(void) {
   /* TH2 */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TH2));
   G__memfunc_setup("TH2",206,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__HistLN_TH2), -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH2",206,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__HistLN_TH2), -1, 0, 8, 1, 2, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx d - 'Double_t' 0 - xlow "
"d - 'Double_t' 0 - xup i - 'Int_t' 0 - nbinsy "
"d - 'Double_t' 0 - ylow d - 'Double_t' 0 - yup", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH2",206,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__HistLN_TH2), -1, 0, 7, 1, 2, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx D - 'Double_t' 10 - xbins "
"i - 'Int_t' 0 - nbinsy d - 'Double_t' 0 - ylow "
"d - 'Double_t' 0 - yup", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH2",206,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__HistLN_TH2), -1, 0, 7, 1, 2, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx d - 'Double_t' 0 - xlow "
"d - 'Double_t' 0 - xup i - 'Int_t' 0 - nbinsy "
"D - 'Double_t' 10 - ybins", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH2",206,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__HistLN_TH2), -1, 0, 6, 1, 2, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx D - 'Double_t' 10 - xbins "
"i - 'Int_t' 0 - nbinsy D - 'Double_t' 10 - ybins", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH2",206,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__HistLN_TH2), -1, 0, 6, 1, 2, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx F - 'Float_t' 10 - xbins "
"i - 'Int_t' 0 - nbinsy F - 'Float_t' 10 - ybins", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BufferFill",993,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 2, 0, 
"d - 'Double_t' 0 - - d - 'Double_t' 0 - -", "may not use", (void*) NULL, 1);
   G__memfunc_setup("BufferFill",993,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 2, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"d - 'Double_t' 0 - w", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoProjection",1232,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__HistLN_TH1D), -1, 0, 5, 1, 2, 8, 
"g - - 0 - onX C - - 10 - name "
"i - 'Int_t' 0 - firstbin i - 'Int_t' 0 - lastbin "
"C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoProfile",900,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__HistLN_TProfile), -1, 0, 5, 1, 2, 8, 
"g - - 0 - onX C - - 10 - name "
"i - 'Int_t' 0 - firstbin i - 'Int_t' 0 - lastbin "
"C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoFitSlices",1081,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 7, 1, 2, 0, 
"g - - 0 - onX U 'TF1' - 0 - f1 "
"i - 'Int_t' 0 - firstbin i - 'Int_t' 0 - lastbin "
"i - 'Int_t' 0 - cut C - 'Option_t' 10 - option "
"U 'TObjArray' - 0 - arr", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TH2",206,G__G__Hist_214_0_12, 105, G__get_linked_tagnum(&G__G__HistLN_TH2), -1, 0, 1, 1, 1, 0, "u 'TH2' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BufferEmpty",1129,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 '0' action", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TObject' - 1 - hnew", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Fill",391,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - -", "MayNotUse", (void*) NULL, 1);
   G__memfunc_setup("Fill",391,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"C - - 10 - - d - 'Double_t' 0 - -", "MayNotUse", (void*) NULL, 1);
   G__memfunc_setup("Fill",391,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Fill",391,G__G__Hist_214_0_18, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"d - 'Double_t' 0 - w", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Fill",391,G__G__Hist_214_0_19, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - x C - - 10 - namey "
"d - 'Double_t' 0 - w", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Fill",391,G__G__Hist_214_0_20, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"C - - 10 - namex d - 'Double_t' 0 - y "
"d - 'Double_t' 0 - w", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Fill",391,G__G__Hist_214_0_21, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"C - - 10 - namex C - - 10 - namey "
"d - 'Double_t' 0 - w", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillN",469,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - - D - 'Double_t' 10 - - "
"D - 'Double_t' 10 - - i - 'Int_t' 0 - -", "MayNotUse", (void*) NULL, 1);
   G__memfunc_setup("FillN",469,G__G__Hist_214_0_23, 121, -1, -1, 0, 5, 1, 1, 0, 
"i - 'Int_t' 0 - ntimes D - 'Double_t' 10 - x "
"D - 'Double_t' 10 - y D - 'Double_t' 10 - w "
"i - 'Int_t' 0 '1' stride", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillRandom",1000,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - fname i - 'Int_t' 0 '5000' ntimes", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillRandom",1000,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TH1' - 0 - h i - 'Int_t' 0 '5000' ntimes", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindFirstBinAbove",1679,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 8, 
"d - 'Double_t' 0 '0' threshold i - 'Int_t' 0 '1' axis", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindLastBinAbove",1563,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 8, 
"d - 'Double_t' 0 '0' threshold i - 'Int_t' 0 '1' axis", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FitSlicesX",990,G__G__Hist_214_0_28, 121, -1, -1, 0, 6, 1, 1, 0, 
"U 'TF1' - 0 '0' f1 i - 'Int_t' 0 '0' firstybin "
"i - 'Int_t' 0 '-1' lastybin i - 'Int_t' 0 '0' cut "
"C - 'Option_t' 10 '\"QNR\"' option U 'TObjArray' - 0 '0' arr", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("FitSlicesY",991,G__G__Hist_214_0_29, 121, -1, -1, 0, 6, 1, 1, 0, 
"U 'TF1' - 0 '0' f1 i - 'Int_t' 0 '0' firstxbin "
"i - 'Int_t' 0 '-1' lastxbin i - 'Int_t' 0 '0' cut "
"C - 'Option_t' 10 '\"QNR\"' option U 'TObjArray' - 0 '0' arr", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("GetBinWithContent2",1762,G__G__Hist_214_0_30, 100, -1, G__defined_typename("Double_t"), 0, 8, 1, 1, 8, 
"d - 'Double_t' 0 - c i - 'Int_t' 1 - binx "
"i - 'Int_t' 1 - biny i - 'Int_t' 0 '1' firstxbin "
"i - 'Int_t' 0 '-1' lastxbin i - 'Int_t' 0 '1' firstybin "
"i - 'Int_t' 0 '-1' lastybin d - 'Double_t' 0 '0' maxdiff", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCorrelationFactor",2049,G__G__Hist_214_0_31, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 '1' axis1 i - 'Int_t' 0 '2' axis2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCovariance",1307,G__G__Hist_214_0_32, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 '1' axis1 i - 'Int_t' 0 '2' axis2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRandom2",947,G__G__Hist_214_0_33, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 1 - x d - 'Double_t' 1 - y", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetStats",815,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - stats", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Integral",822,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Integral",822,G__G__Hist_214_0_36, 100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"i - 'Int_t' 0 - binx1 i - 'Int_t' 0 - binx2 "
"i - 'Int_t' 0 - biny1 i - 'Int_t' 0 - biny2 "
"C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Integral",822,G__G__Hist_214_0_37, 100, -1, G__defined_typename("Double_t"), 0, 7, 1, 1, 8, 
"i - 'Int_t' 0 - - i - 'Int_t' 0 - - "
"i - 'Int_t' 0 - - i - 'Int_t' 0 - - "
"i - 'Int_t' 0 - - i - 'Int_t' 0 - - "
"C - 'Option_t' 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IntegralAndError",1619,G__G__Hist_214_0_38, 100, -1, G__defined_typename("Double_t"), 0, 6, 1, 1, 8, 
"i - 'Int_t' 0 - binx1 i - 'Int_t' 0 - binx2 "
"i - 'Int_t' 0 - biny1 i - 'Int_t' 0 - biny2 "
"d - 'Double_t' 1 - err C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Interpolate",1159,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Interpolate",1159,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Interpolate",1159,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("KolmogorovTest",1487,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"U 'TH1' - 10 - h2 C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Merge",496,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 1, 1, 1, 0, "U 'TCollection' - 0 - list", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RebinX",584,G__G__Hist_214_0_44, 85, G__get_linked_tagnum(&G__G__HistLN_TH2), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 '2' ngroup C - - 10 '\"\"' newname", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RebinY",585,G__G__Hist_214_0_45, 85, G__get_linked_tagnum(&G__G__HistLN_TH2), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 '2' ngroup C - - 10 '\"\"' newname", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Rebin2D",614,G__G__Hist_214_0_46, 85, G__get_linked_tagnum(&G__G__HistLN_TH2), -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 '2' nxgroup i - 'Int_t' 0 '2' nygroup "
"C - - 10 '\"\"' newname", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProfileX",809,G__G__Hist_214_0_47, 85, G__get_linked_tagnum(&G__G__HistLN_TProfile), -1, 0, 4, 1, 1, 8, 
"C - - 10 '\"_pfx\"' name i - 'Int_t' 0 '1' firstybin "
"i - 'Int_t' 0 '-1' lastybin C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("ProfileY",810,G__G__Hist_214_0_48, 85, G__get_linked_tagnum(&G__G__HistLN_TProfile), -1, 0, 4, 1, 1, 8, 
"C - - 10 '\"_pfy\"' name i - 'Int_t' 0 '1' firstxbin "
"i - 'Int_t' 0 '-1' lastxbin C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("ProjectionX",1141,G__G__Hist_214_0_49, 85, G__get_linked_tagnum(&G__G__HistLN_TH1D), -1, 0, 4, 1, 1, 8, 
"C - - 10 '\"_px\"' name i - 'Int_t' 0 '0' firstybin "
"i - 'Int_t' 0 '-1' lastybin C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("ProjectionY",1142,G__G__Hist_214_0_50, 85, G__get_linked_tagnum(&G__G__HistLN_TH1D), -1, 0, 4, 1, 1, 8, 
"C - - 10 '\"_py\"' name i - 'Int_t' 0 '0' firstxbin "
"i - 'Int_t' 0 '-1' lastxbin C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("PutStats",840,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - stats", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Reset",515,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetShowProjectionX",1858,G__G__Hist_214_0_53, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - nbins", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetShowProjectionY",1859,G__G__Hist_214_0_54, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - nbins", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("ShowBackground",1441,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TH1), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 '20' niter C - 'Option_t' 10 '\"same\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowPeaks",917,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 '2' sigma C - 'Option_t' 10 '\"\"' option "
"d - 'Double_t' 0 '0.05' threshold", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Smooth",634,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 '1' ntimes C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Hist_214_0_58, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TH2::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_214_0_59, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH2::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_214_0_60, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TH2::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_214_0_61, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TH2::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_214_0_65, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_214_0_66, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH2::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_214_0_67, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TH2::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_214_0_68, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH2::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_214_0_69, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TH2::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TH2", 332, G__G__Hist_214_0_70, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEfficiency(void) {
   /* TEfficiency */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TEfficiency));
   G__memfunc_setup("Build",496,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"C - - 10 - name C - - 10 - title", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEfficiency",1097,G__G__Hist_215_0_2, 105, G__get_linked_tagnum(&G__G__HistLN_TEfficiency), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEfficiency",1097,G__G__Hist_215_0_3, 105, G__get_linked_tagnum(&G__G__HistLN_TEfficiency), -1, 0, 2, 1, 1, 0, 
"u 'TH1' - 11 - passed u 'TH1' - 11 - total", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEfficiency",1097,G__G__Hist_215_0_4, 105, G__get_linked_tagnum(&G__G__HistLN_TEfficiency), -1, 0, 4, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbins D - 'Double_t' 10 - xbins", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEfficiency",1097,G__G__Hist_215_0_5, 105, G__get_linked_tagnum(&G__G__HistLN_TEfficiency), -1, 0, 5, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbins d - 'Double_t' 0 - xlow "
"d - 'Double_t' 0 - xup", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEfficiency",1097,G__G__Hist_215_0_6, 105, G__get_linked_tagnum(&G__G__HistLN_TEfficiency), -1, 0, 8, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx d - 'Double_t' 0 - xlow "
"d - 'Double_t' 0 - xup i - 'Int_t' 0 - nbinsy "
"d - 'Double_t' 0 - ylow d - 'Double_t' 0 - yup", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEfficiency",1097,G__G__Hist_215_0_7, 105, G__get_linked_tagnum(&G__G__HistLN_TEfficiency), -1, 0, 6, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx D - 'Double_t' 10 - xbins "
"i - 'Int_t' 0 - nbinsy D - 'Double_t' 10 - ybins", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEfficiency",1097,G__G__Hist_215_0_8, 105, G__get_linked_tagnum(&G__G__HistLN_TEfficiency), -1, 0, 11, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx d - 'Double_t' 0 - xlow "
"d - 'Double_t' 0 - xup i - 'Int_t' 0 - nbinsy "
"d - 'Double_t' 0 - ylow d - 'Double_t' 0 - yup "
"i - 'Int_t' 0 - nbinsz d - 'Double_t' 0 - zlow "
"d - 'Double_t' 0 - zup", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEfficiency",1097,G__G__Hist_215_0_9, 105, G__get_linked_tagnum(&G__G__HistLN_TEfficiency), -1, 0, 8, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx D - 'Double_t' 10 - xbins "
"i - 'Int_t' 0 - nbinsy D - 'Double_t' 10 - ybins "
"i - 'Int_t' 0 - nbinsz D - 'Double_t' 10 - zbins", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEfficiency",1097,G__G__Hist_215_0_10, 105, G__get_linked_tagnum(&G__G__HistLN_TEfficiency), -1, 0, 1, 1, 1, 0, "u 'TEfficiency' - 11 - heff", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Add",265,G__G__Hist_215_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TEfficiency' - 11 - rEff", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Fill",391,G__G__Hist_215_0_15, 121, -1, -1, 0, 4, 1, 1, 0, 
"g - 'Bool_t' 0 - bPassed d - 'Double_t' 0 - x "
"d - 'Double_t' 0 '0' y d - 'Double_t' 0 '0' z", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindFixBin",961,G__G__Hist_215_0_16, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 8, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 '0' y "
"d - 'Double_t' 0 '0' z", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Fit",291,G__G__Hist_215_0_17, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"U 'TF1' - 0 - f1 C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBetaAlpha",1154,G__G__Hist_215_0_18, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 '-1' bin", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBetaBeta",1048,G__G__Hist_215_0_19, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 '-1' bin", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetConfidenceLevel",1798,G__G__Hist_215_0_20, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCopyPassedHisto",1826,G__G__Hist_215_0_21, 85, G__get_linked_tagnum(&G__G__HistLN_TH1), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCopyTotalHisto",1734,G__G__Hist_215_0_22, 85, G__get_linked_tagnum(&G__G__HistLN_TH1), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDimension",1222,G__G__Hist_215_0_23, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDirectory",1237,G__G__Hist_215_0_24, 85, G__get_linked_tagnum(&G__G__HistLN_TDirectory), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEfficiency",1301,G__G__Hist_215_0_25, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEfficiencyErrorLow",2129,G__G__Hist_215_0_26, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEfficiencyErrorUp",2020,G__G__Hist_215_0_27, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGlobalBin",1162,G__G__Hist_215_0_28, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - binx i - 'Int_t' 0 '0' biny "
"i - 'Int_t' 0 '0' binz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPaintedGraph",1495,G__G__Hist_215_0_29, 85, G__get_linked_tagnum(&G__G__HistLN_TGraphAsymmErrors), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPaintedHistogram",1939,G__G__Hist_215_0_30, 85, G__get_linked_tagnum(&G__G__HistLN_TH2), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListOfFunctions",1834,G__G__Hist_215_0_31, 85, G__get_linked_tagnum(&G__G__HistLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPassedHistogram",1838,G__G__Hist_215_0_32, 85, G__get_linked_tagnum(&G__G__HistLN_TH1), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStatisticOption",1873,G__G__Hist_215_0_33, 105, G__get_linked_tagnum(&G__G__HistLN_TEfficiencycLcLEStatOption), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTotalHistogram",1746,G__G__Hist_215_0_34, 85, G__get_linked_tagnum(&G__G__HistLN_TH1), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetWeight",904,G__G__Hist_215_0_35, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Merge",496,G__G__Hist_215_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TCollection' - 0 - list", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Hist_215_0_37, 117, G__get_linked_tagnum(&G__G__HistLN_TEfficiency), -1, 1, 1, 1, 1, 0, "u 'TEfficiency' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Hist_215_0_38, 117, G__get_linked_tagnum(&G__G__HistLN_TEfficiency), -1, 1, 1, 1, 1, 0, "u 'TEfficiency' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBetaAlpha",1166,G__G__Hist_215_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - alpha", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBetaBeta",1060,G__G__Hist_215_0_42, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - beta", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBetaBinParameters",2005,G__G__Hist_215_0_43, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - bin d - 'Double_t' 0 - alpha "
"d - 'Double_t' 0 - beta", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetConfidenceLevel",1810,G__G__Hist_215_0_44, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - level", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDirectory",1249,G__G__Hist_215_0_45, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TDirectory' - 0 - dir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetName",685,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPassedEvents",1537,G__G__Hist_215_0_47, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - bin i - 'Int_t' 0 - events", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPassedHistogram",1850,G__G__Hist_215_0_48, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TH1' - 11 - rPassed C - 'Option_t' 10 - opt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPosteriorMode",1656,G__G__Hist_215_0_49, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'true' on", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPosteriorAverage",1966,G__G__Hist_215_0_50, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'true' on", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetShortestInterval",1997,G__G__Hist_215_0_51, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'true' on", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCentralInterval",1850,G__G__Hist_215_0_52, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'true' on", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetStatisticOption",1885,G__G__Hist_215_0_53, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TEfficiency::EStatOption' - 0 - option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTitle",814,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - title", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTotalEvents",1445,G__G__Hist_215_0_55, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - bin i - 'Int_t' 0 - events", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTotalHistogram",1758,G__G__Hist_215_0_56, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TH1' - 11 - rTotal C - 'Option_t' 10 - opt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetWeight",916,G__G__Hist_215_0_57, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - weight", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UsesBayesianStat",1640,G__G__Hist_215_0_58, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UsesPosteriorMode",1772,G__G__Hist_215_0_59, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UsesShortestInterval",2113,G__G__Hist_215_0_60, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UsesPosteriorAverage",2082,G__G__Hist_215_0_61, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UsesCentralInterval",1966,G__G__Hist_215_0_62, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckBinning",1187,G__G__Hist_215_0_63, 103, -1, G__defined_typename("Bool_t"), 0, 2, 3, 1, 0, 
"u 'TH1' - 11 - pass u 'TH1' - 11 - total", (char*)NULL, (void*) G__func2void( (Bool_t (*)(const TH1&, const TH1&))(&TEfficiency::CheckBinning) ), 0);
   G__memfunc_setup("CheckConsistency",1648,G__G__Hist_215_0_64, 103, -1, G__defined_typename("Bool_t"), 0, 3, 3, 1, 0, 
"u 'TH1' - 11 - pass u 'TH1' - 11 - total "
"C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) G__func2void( (Bool_t (*)(const TH1&, const TH1&, Option_t*))(&TEfficiency::CheckConsistency) ), 0);
   G__memfunc_setup("CheckEntries",1208,G__G__Hist_215_0_65, 103, -1, G__defined_typename("Bool_t"), 0, 3, 3, 1, 0, 
"u 'TH1' - 11 - pass u 'TH1' - 11 - total "
"C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) G__func2void( (Bool_t (*)(const TH1&, const TH1&, Option_t*))(&TEfficiency::CheckEntries) ), 0);
   G__memfunc_setup("Combine",701,G__G__Hist_215_0_66, 100, -1, G__defined_typename("Double_t"), 0, 10, 3, 1, 0, 
"d - 'Double_t' 1 - up d - 'Double_t' 1 - low "
"i - 'Int_t' 0 - n I - 'Int_t' 10 - pass "
"I - 'Int_t' 10 - total d - 'Double_t' 0 - alpha "
"d - 'Double_t' 0 - beta d - 'Double_t' 0 '0.683' level "
"D - 'Double_t' 10 '0' w C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) G__func2void( (Double_t (*)(Double_t&, Double_t&, Int_t, const Int_t*, const Int_t*, Double_t, Double_t, Double_t, const Double_t*, Option_t*))(&TEfficiency::Combine) ), 0);
   G__memfunc_setup("Combine",701,G__G__Hist_215_0_67, 85, G__get_linked_tagnum(&G__G__HistLN_TGraphAsymmErrors), -1, 0, 4, 3, 1, 0, 
"U 'TCollection' - 0 - pList C - 'Option_t' 10 '\"\"' opt "
"i - 'Int_t' 0 '0' n D - 'Double_t' 10 '0' w", (char*)NULL, (void*) G__func2void( (TGraphAsymmErrors* (*)(TCollection*, Option_t*, Int_t, const Double_t*))(&TEfficiency::Combine) ), 0);
   G__memfunc_setup("AgrestiCoull",1230,G__G__Hist_215_0_68, 100, -1, G__defined_typename("Double_t"), 0, 4, 3, 1, 0, 
"i - 'Int_t' 0 - total i - 'Int_t' 0 - passed "
"d - 'Double_t' 0 - level g - 'Bool_t' 0 - bUpper", (char*)NULL, (void*) G__func2void( (Double_t (*)(Int_t, Int_t, Double_t, Bool_t))(&TEfficiency::AgrestiCoull) ), 0);
   G__memfunc_setup("ClopperPearson",1453,G__G__Hist_215_0_69, 100, -1, G__defined_typename("Double_t"), 0, 4, 3, 1, 0, 
"i - 'Int_t' 0 - total i - 'Int_t' 0 - passed "
"d - 'Double_t' 0 - level g - 'Bool_t' 0 - bUpper", (char*)NULL, (void*) G__func2void( (Double_t (*)(Int_t, Int_t, Double_t, Bool_t))(&TEfficiency::ClopperPearson) ), 0);
   G__memfunc_setup("Normal",617,G__G__Hist_215_0_70, 100, -1, G__defined_typename("Double_t"), 0, 4, 3, 1, 0, 
"i - 'Int_t' 0 - total i - 'Int_t' 0 - passed "
"d - 'Double_t' 0 - level g - 'Bool_t' 0 - bUpper", (char*)NULL, (void*) G__func2void( (Double_t (*)(Int_t, Int_t, Double_t, Bool_t))(&TEfficiency::Normal) ), 0);
   G__memfunc_setup("Wilson",636,G__G__Hist_215_0_71, 100, -1, G__defined_typename("Double_t"), 0, 4, 3, 1, 0, 
"i - 'Int_t' 0 - total i - 'Int_t' 0 - passed "
"d - 'Double_t' 0 - level g - 'Bool_t' 0 - bUpper", (char*)NULL, (void*) G__func2void( (Double_t (*)(Int_t, Int_t, Double_t, Bool_t))(&TEfficiency::Wilson) ), 0);
   G__memfunc_setup("FeldmanCousins",1435,G__G__Hist_215_0_72, 100, -1, G__defined_typename("Double_t"), 0, 4, 3, 1, 0, 
"i - 'Int_t' 0 - total i - 'Int_t' 0 - passed "
"d - 'Double_t' 0 - level g - 'Bool_t' 0 - bUpper", (char*)NULL, (void*) G__func2void( (Double_t (*)(Int_t, Int_t, Double_t, Bool_t))(&TEfficiency::FeldmanCousins) ), 0);
   G__memfunc_setup("FeldmanCousinsInterval",2272,G__G__Hist_215_0_73, 103, -1, G__defined_typename("Bool_t"), 0, 5, 3, 1, 0, 
"i - 'Int_t' 0 - total i - 'Int_t' 0 - passed "
"d - 'Double_t' 0 - level d - 'Double_t' 1 - lower "
"d - 'Double_t' 1 - upper", (char*)NULL, (void*) G__func2void( (Bool_t (*)(Int_t, Int_t, Double_t, Double_t&, Double_t&))(&TEfficiency::FeldmanCousinsInterval) ), 0);
   G__memfunc_setup("Bayesian",812,G__G__Hist_215_0_74, 100, -1, G__defined_typename("Double_t"), 0, 7, 3, 1, 0, 
"i - 'Int_t' 0 - total i - 'Int_t' 0 - passed "
"d - 'Double_t' 0 - level d - 'Double_t' 0 - alpha "
"d - 'Double_t' 0 - beta g - 'Bool_t' 0 - bUpper "
"g - 'Bool_t' 0 'false' bShortest", (char*)NULL, (void*) G__func2void( (Double_t (*)(Int_t, Int_t, Double_t, Double_t, Double_t, Bool_t, Bool_t))(&TEfficiency::Bayesian) ), 0);
   G__memfunc_setup("BetaCentralInterval",1930,G__G__Hist_215_0_75, 100, -1, G__defined_typename("Double_t"), 0, 4, 3, 1, 0, 
"d - 'Double_t' 0 - level d - 'Double_t' 0 - alpha "
"d - 'Double_t' 0 - beta g - 'Bool_t' 0 - bUpper", (char*)NULL, (void*) G__func2void( (Double_t (*)(Double_t, Double_t, Double_t, Bool_t))(&TEfficiency::BetaCentralInterval) ), 0);
   G__memfunc_setup("BetaShortestInterval",2077,G__G__Hist_215_0_76, 103, -1, G__defined_typename("Bool_t"), 0, 5, 3, 1, 0, 
"d - 'Double_t' 0 - level d - 'Double_t' 0 - alpha "
"d - 'Double_t' 0 - beta d - 'Double_t' 1 - lower "
"d - 'Double_t' 1 - upper", (char*)NULL, (void*) G__func2void( (Bool_t (*)(Double_t, Double_t, Double_t, Double_t&, Double_t&))(&TEfficiency::BetaShortestInterval) ), 0);
   G__memfunc_setup("BetaMean",765,G__G__Hist_215_0_77, 100, -1, G__defined_typename("Double_t"), 0, 2, 3, 1, 0, 
"d - 'Double_t' 0 - alpha d - 'Double_t' 0 - beta", (char*)NULL, (void*) G__func2void( (Double_t (*)(Double_t, Double_t))(&TEfficiency::BetaMean) ), 0);
   G__memfunc_setup("BetaMode",769,G__G__Hist_215_0_78, 100, -1, G__defined_typename("Double_t"), 0, 2, 3, 1, 0, 
"d - 'Double_t' 0 - alpha d - 'Double_t' 0 - beta", (char*)NULL, (void*) G__func2void( (Double_t (*)(Double_t, Double_t))(&TEfficiency::BetaMode) ), 0);
   G__memfunc_setup("Class",502,G__G__Hist_215_0_79, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEfficiency::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_215_0_80, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEfficiency::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_215_0_81, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEfficiency::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_215_0_82, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEfficiency::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_215_0_86, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_215_0_87, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEfficiency::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_215_0_88, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEfficiency::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_215_0_89, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEfficiency::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_215_0_90, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEfficiency::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEfficiency", 1223, G__G__Hist_215_0_91, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTFormulaPrimitive(void) {
   /* TFormulaPrimitive */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TFormulaPrimitive));
   G__memfunc_setup("BuildBasicFormulas",1819,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 3, 2, 0, "", "build list of basic formulas", (void*) NULL, 0);
   G__memfunc_setup("TFormulaPrimitive",1763,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__HistLN_TFormulaPrimitive), -1, 0, 1, 1, 4, 0, "u 'TFormulaPrimitive' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__HistLN_TFormulaPrimitive), -1, 1, 1, 1, 4, 0, "u 'TFormulaPrimitive' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TFormulaPrimitive",1763,G__G__Hist_227_0_4, 105, G__get_linked_tagnum(&G__G__HistLN_TFormulaPrimitive), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TFormulaPrimitive",1763,G__G__Hist_227_0_5, 105, G__get_linked_tagnum(&G__G__HistLN_TFormulaPrimitive), -1, 0, 3, 1, 1, 0, 
"C - - 10 - name C - - 10 - formula "
"Y - 'TFormulaPrimitive::GenFunc0' 0 - fpointer", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TFormulaPrimitive",1763,G__G__Hist_227_0_6, 105, G__get_linked_tagnum(&G__G__HistLN_TFormulaPrimitive), -1, 0, 4, 1, 1, 0, 
"C - - 10 - name C - - 10 - formula "
"Y - 'TFormulaPrimitive::GenFuncG' 0 - fpointer i - 'Int_t' 0 - npar", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TFormulaPrimitive",1763,G__G__Hist_227_0_7, 105, G__get_linked_tagnum(&G__G__HistLN_TFormulaPrimitive), -1, 0, 3, 1, 1, 0, 
"C - - 10 - name C - - 10 - formula "
"a - 'TFormulaPrimitive::TFunc0' 0 - fpointer", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddFormula",991,G__G__Hist_227_0_8, 105, -1, G__defined_typename("Int_t"), 0, 1, 3, 1, 0, "U 'TFormulaPrimitive' - 0 - formula", (char*)NULL, (void*) G__func2void( (Int_t (*)(TFormulaPrimitive*))(&TFormulaPrimitive::AddFormula) ), 0);
   G__memfunc_setup("FindFormula",1111,G__G__Hist_227_0_9, 85, G__get_linked_tagnum(&G__G__HistLN_TFormulaPrimitive), -1, 0, 1, 3, 1, 0, "C - - 10 - name", (char*)NULL, (void*) G__func2void( (TFormulaPrimitive* (*)(const char*))(&TFormulaPrimitive::FindFormula) ), 0);
   G__memfunc_setup("FindFormula",1111,G__G__Hist_227_0_10, 85, G__get_linked_tagnum(&G__G__HistLN_TFormulaPrimitive), -1, 0, 2, 3, 1, 0, 
"C - - 10 - name C - - 10 - args", (char*)NULL, (void*) G__func2void( (TFormulaPrimitive* (*)(const char*, const char*))(&TFormulaPrimitive::FindFormula) ), 0);
   G__memfunc_setup("FindFormula",1111,G__G__Hist_227_0_11, 85, G__get_linked_tagnum(&G__G__HistLN_TFormulaPrimitive), -1, 0, 2, 3, 1, 0, 
"C - - 10 - name h - 'UInt_t' 0 - nargs", (char*)NULL, (void*) G__func2void( (TFormulaPrimitive* (*)(const char*, UInt_t))(&TFormulaPrimitive::FindFormula) ), 0);
   G__memfunc_setup("Eval",392,G__G__Hist_227_0_12, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "D - 'Double_t' 0 - x", "eval primitive function", (void*) NULL, 0);
   G__memfunc_setup("Eval",392,G__G__Hist_227_0_13, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - o D - 'Double_t' 0 - x", "eval member function", (void*) NULL, 0);
   G__memfunc_setup("Eval",392,G__G__Hist_227_0_14, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"D - 'Double_t' 0 - x D - 'Double_t' 0 - param", "eval primitive parametric function", (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Hist_227_0_15, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TFormulaPrimitive::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_227_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFormulaPrimitive::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_227_0_17, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TFormulaPrimitive::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_227_0_18, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TFormulaPrimitive::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_227_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_227_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFormulaPrimitive::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_227_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TFormulaPrimitive::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_227_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFormulaPrimitive::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_227_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TFormulaPrimitive::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TFormulaPrimitive", 1889, G__G__Hist_227_0_27, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTFormula(void) {
   /* TFormula */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TFormula));
   G__memfunc_setup("PreCompile",1008,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckOperands",1306,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 2, 0, 
"i - 'Int_t' 0 - operation i - 'Int_t' 1 - err", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CheckOperands",1306,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 2, 0, 
"i - 'Int_t' 0 - leftoperand i - 'Int_t' 0 - rightoperartion "
"i - 'Int_t' 1 - err", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StringToNumber",1443,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 2, 0, "i - 'Int_t' 0 - code", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakePrimitive",1335,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"C - - 10 - expr i - 'Int_t' 0 - pos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOper",694,(G__InterfaceMethod) NULL, 73, -1, G__defined_typename("Int_t"), 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAction",894,(G__InterfaceMethod) NULL, 115, -1, G__defined_typename("Short_t"), 0, 1, 1, 2, 8, "i - 'Int_t' 0 - code", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetActionParam",1391,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 8, "i - 'Int_t' 0 - code", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAction",906,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"i - 'Int_t' 0 - code i - 'Int_t' 0 - value "
"i - 'Int_t' 0 '0' param", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOperOptimized",1643,(G__InterfaceMethod) NULL, 73, -1, G__defined_typename("Int_t"), 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetActionOptimized",1843,(G__InterfaceMethod) NULL, 115, -1, G__defined_typename("Short_t"), 0, 1, 1, 2, 8, "i - 'Int_t' 0 - code", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetActionParamOptimized",2340,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 8, "i - 'Int_t' 0 - code", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetActionOptimized",1855,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"i - 'Int_t' 0 - code i - 'Int_t' 0 - value "
"i - 'Int_t' 0 '0' param", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ClearFormula",1213,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsString",819,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 2, 8, "i - 'Int_t' 0 - oper", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Convert",737,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "h - 'UInt_t' 0 - fromVersion", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("EvalParFast",1081,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 2, 0, 
"D - 'Double_t' 10 - x D - 'Double_t' 10 - params", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EvalPrimitive",1345,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 2, 0, 
"D - 'Double_t' 10 - x D - 'Double_t' 10 - params", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EvalPrimitive0",1393,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 2, 0, 
"D - 'Double_t' 10 - x D - 'Double_t' 10 - params", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EvalPrimitive1",1394,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 2, 0, 
"D - 'Double_t' 10 - x D - 'Double_t' 10 - params", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EvalPrimitive2",1395,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 2, 0, 
"D - 'Double_t' 10 - x D - 'Double_t' 10 - params", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EvalPrimitive3",1396,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 2, 0, 
"D - 'Double_t' 10 - x D - 'Double_t' 10 - params", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EvalPrimitive4",1397,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 2, 0, 
"D - 'Double_t' 10 - x D - 'Double_t' 10 - params", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TFormula",810,G__G__Hist_229_0_24, 105, G__get_linked_tagnum(&G__G__HistLN_TFormula), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TFormula",810,G__G__Hist_229_0_25, 105, G__get_linked_tagnum(&G__G__HistLN_TFormula), -1, 0, 2, 1, 1, 0, 
"C - - 10 - name C - - 10 - formula", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TFormula",810,G__G__Hist_229_0_26, 105, G__get_linked_tagnum(&G__G__HistLN_TFormula), -1, 0, 1, 1, 1, 0, "u 'TFormula' - 11 - formula", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Hist_229_0_27, 117, G__get_linked_tagnum(&G__G__HistLN_TFormula), -1, 1, 1, 1, 1, 0, "u 'TFormula' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Optimize",849,G__G__Hist_229_0_28, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Analyze",724,G__G__Hist_229_0_29, 121, -1, -1, 0, 3, 1, 1, 0, 
"C - - 10 - schain i - 'Int_t' 1 - err "
"i - 'Int_t' 0 '0' offset", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AnalyzeFunction",1562,G__G__Hist_229_0_30, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"u 'TString' - 1 - chaine i - 'Int_t' 1 - err "
"i - 'Int_t' 0 '0' offset", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Compile",713,G__G__Hist_229_0_31, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - - 10 '\"\"' expression", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TObject' - 1 - formula", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DefinedString",1318,G__G__Hist_229_0_34, 67, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - code", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DefinedValue",1196,G__G__Hist_229_0_35, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - code", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DefinedVariable",1493,G__G__Hist_229_0_36, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"u 'TString' - 1 - variable i - 'Int_t' 1 - action", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Eval",392,G__G__Hist_229_0_37, 100, -1, G__defined_typename("Double_t"), 0, 4, 1, 1, 8, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 '0' y "
"d - 'Double_t' 0 '0' z d - 'Double_t' 0 '0' t", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("EvalParOld",970,G__G__Hist_229_0_38, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"D - 'Double_t' 10 - x D - 'Double_t' 10 '0' params", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("EvalPar",683,G__G__Hist_229_0_39, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"D - 'Double_t' 10 - x D - 'Double_t' 10 '0' params", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLinearPart",1298,G__G__Hist_229_0_40, 85, G__get_linked_tagnum(&G__G__HistLN_TObject), -1, 0, 1, 1, 1, 1, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNdim",680,G__G__Hist_229_0_41, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNpar",689,G__G__Hist_229_0_42, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNumber",905,G__G__Hist_229_0_43, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetExpFormula",1315,G__G__Hist_229_0_44, 117, G__get_linked_tagnum(&G__G__HistLN_TString), -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetParameter",1217,G__G__Hist_229_0_45, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - ipar", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetParameter",1217,G__G__Hist_229_0_46, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetParameters",1332,G__G__Hist_229_0_47, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetParameters",1332,G__G__Hist_229_0_48, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - params", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetParName",964,G__G__Hist_229_0_49, 67, -1, -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - ipar", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetParNumber",1196,G__G__Hist_229_0_50, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsLinear",791,G__G__Hist_229_0_51, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsNormalized",1233,G__G__Hist_229_0_52, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("ProcessLinear",1338,G__G__Hist_229_0_54, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 1 - replaceformula", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetNumber",917,G__G__Hist_229_0_55, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - number", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetParameter",1229,G__G__Hist_229_0_56, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - name d - 'Double_t' 0 - parvalue", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetParameter",1229,G__G__Hist_229_0_57, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - ipar d - 'Double_t' 0 - parvalue", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetParameters",1344,G__G__Hist_229_0_58, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - params", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetParameters",1344,G__G__Hist_229_0_59, 121, -1, -1, 0, 11, 1, 1, 0, 
"d - 'Double_t' 0 - p0 d - 'Double_t' 0 - p1 "
"d - 'Double_t' 0 '0' p2 d - 'Double_t' 0 '0' p3 "
"d - 'Double_t' 0 '0' p4 d - 'Double_t' 0 '0' p5 "
"d - 'Double_t' 0 '0' p6 d - 'Double_t' 0 '0' p7 "
"d - 'Double_t' 0 '0' p8 d - 'Double_t' 0 '0' p9 "
"d - 'Double_t' 0 '0' p10", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetParName",976,G__G__Hist_229_0_60, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - ipar C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetParNames",1091,G__G__Hist_229_0_61, 121, -1, -1, 0, 11, 1, 1, 0, 
"C - - 10 '\"p0\"' name0 C - - 10 '\"p1\"' name1 "
"C - - 10 '\"p2\"' name2 C - - 10 '\"p3\"' name3 "
"C - - 10 '\"p4\"' name4 C - - 10 '\"p5\"' name5 "
"C - - 10 '\"p6\"' name6 C - - 10 '\"p7\"' name7 "
"C - - 10 '\"p8\"' name8 C - - 10 '\"p9\"' name9 "
"C - - 10 '\"p10\"' name10", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Update",611,G__G__Hist_229_0_62, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMaxima",905,G__G__Hist_229_0_63, 121, -1, -1, 0, 3, 3, 1, 0, 
"i - 'Int_t' 0 '1000' maxop i - 'Int_t' 0 '1000' maxpar "
"i - 'Int_t' 0 '1000' maxconst", (char*)NULL, (void*) G__func2void( (void (*)(Int_t, Int_t, Int_t))(&TFormula::SetMaxima) ), 0);
   G__memfunc_setup("Class",502,G__G__Hist_229_0_64, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TFormula::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_229_0_65, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFormula::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_229_0_66, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TFormula::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_229_0_67, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TFormula::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_229_0_71, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_229_0_72, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFormula::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_229_0_73, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TFormula::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_229_0_74, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFormula::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_229_0_75, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TFormula::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TFormula", 936, G__G__Hist_229_0_76, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTF12(void) {
   /* TF12 */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TF12));
   G__memfunc_setup("TF12",253,G__G__Hist_235_0_1, 105, G__get_linked_tagnum(&G__G__HistLN_TF12), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TF12",253,G__G__Hist_235_0_2, 105, G__get_linked_tagnum(&G__G__HistLN_TF12), -1, 0, 4, 1, 1, 0, 
"C - - 10 - name U 'TF2' - 0 - f2 "
"d - 'Double_t' 0 - xy C - 'Option_t' 10 '\"x\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TF12",253,G__G__Hist_235_0_3, 105, G__get_linked_tagnum(&G__G__HistLN_TF12), -1, 0, 1, 1, 1, 0, "u 'TF12' - 11 - f12", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TObject' - 1 - f12", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawCopy",809,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TF1), -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Eval",392,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 4, 1, 1, 8, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 '0' y "
"d - 'Double_t' 0 '0' z d - 'Double_t' 0 '0' t", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("EvalPar",683,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"D - 'Double_t' 10 - x D - 'Double_t' 10 '0' params", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetXY",465,G__G__Hist_235_0_8, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetXY",477,G__G__Hist_235_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - xy", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Hist_235_0_11, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TF12::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_235_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TF12::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_235_0_13, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TF12::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_235_0_14, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TF12::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_235_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_235_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TF12::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_235_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TF12::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_235_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TF12::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_235_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TF12::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TF12", 379, G__G__Hist_235_0_23, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTF3(void) {
   /* TF3 */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TF3));
   G__memfunc_setup("TF3",205,G__G__Hist_236_0_1, 105, G__get_linked_tagnum(&G__G__HistLN_TF3), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TF3",205,G__G__Hist_236_0_2, 105, G__get_linked_tagnum(&G__G__HistLN_TF3), -1, 0, 8, 1, 1, 0, 
"C - - 10 - name C - - 10 - formula "
"d - 'Double_t' 0 '0' xmin d - 'Double_t' 0 '1' xmax "
"d - 'Double_t' 0 '0' ymin d - 'Double_t' 0 '1' ymax "
"d - 'Double_t' 0 '0' zmin d - 'Double_t' 0 '1' zmax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TF3",205,G__G__Hist_236_0_3, 105, G__get_linked_tagnum(&G__G__HistLN_TF3), -1, 0, 9, 1, 1, 0, 
"C - - 10 - name Y - - 0 - fcn "
"d - 'Double_t' 0 '0' xmin d - 'Double_t' 0 '1' xmax "
"d - 'Double_t' 0 '0' ymin d - 'Double_t' 0 '1' ymax "
"d - 'Double_t' 0 '0' zmin d - 'Double_t' 0 '1' zmax "
"i - 'Int_t' 0 '0' npar", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TF3",205,G__G__Hist_236_0_4, 105, G__get_linked_tagnum(&G__G__HistLN_TF3), -1, 0, 9, 1, 1, 0, 
"C - - 10 - name u 'ROOT::Math::ParamFunctor' - 0 - f "
"d - 'Double_t' 0 '0' xmin d - 'Double_t' 0 '1' xmax "
"d - 'Double_t' 0 '0' ymin d - 'Double_t' 0 '1' ymax "
"d - 'Double_t' 0 '0' zmin d - 'Double_t' 0 '1' zmax "
"i - 'Int_t' 0 '0' npar", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TF3",205,G__G__Hist_236_0_5, 105, G__get_linked_tagnum(&G__G__HistLN_TF3), -1, 0, 10, 1, 1, 0, 
"C - - 10 - name Y - - 0 - ptr "
"d - 'Double_t' 0 - xmin d - 'Double_t' 0 - xmax "
"d - 'Double_t' 0 - ymin d - 'Double_t' 0 - ymax "
"d - 'Double_t' 0 - zmin d - 'Double_t' 0 - zmax "
"i - 'Int_t' 0 - npar C - - 10 - className", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TF3",205,G__G__Hist_236_0_6, 105, G__get_linked_tagnum(&G__G__HistLN_TF3), -1, 0, 12, 1, 1, 0, 
"C - - 10 - name Y - - 0 - ptr "
"Y - - 0 - - d - 'Double_t' 0 - xmin "
"d - 'Double_t' 0 - xmax d - 'Double_t' 0 - ymin "
"d - 'Double_t' 0 - ymax d - 'Double_t' 0 - zmin "
"d - 'Double_t' 0 - zmax i - 'Int_t' 0 - npar "
"C - - 10 - className C - - 10 '0' methodName", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TF3",205,G__G__Hist_236_0_7, 105, G__get_linked_tagnum(&G__G__HistLN_TF3), -1, 0, 1, 1, 1, 0, "u 'TF3' - 11 - f3", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Hist_236_0_8, 117, G__get_linked_tagnum(&G__G__HistLN_TF3), -1, 1, 1, 1, 1, 0, "u 'TF3' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TObject' - 1 - f3", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawDerivative",1441,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TObject), -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"al\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawIntegral",1220,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TObject), -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"al\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMinimumXYZ",1287,G__G__Hist_236_0_15, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 1 - x d - 'Double_t' 1 - y "
"d - 'Double_t' 1 - z", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNpz",600,G__G__Hist_236_0_16, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRandom3",948,G__G__Hist_236_0_17, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 1 - xrandom d - 'Double_t' 1 - yrandom "
"d - 'Double_t' 1 - zrandom", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRange",781,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 8, 
"d - 'Double_t' 1 - xmin d - 'Double_t' 1 - xmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRange",781,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 8, 
"d - 'Double_t' 1 - xmin d - 'Double_t' 1 - ymin "
"d - 'Double_t' 1 - xmax d - 'Double_t' 1 - ymax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRange",781,(G__InterfaceMethod) NULL,121, -1, -1, 0, 6, 1, 1, 8, 
"d - 'Double_t' 1 - xmin d - 'Double_t' 1 - ymin "
"d - 'Double_t' 1 - zmin d - 'Double_t' 1 - xmax "
"d - 'Double_t' 1 - ymax d - 'Double_t' 1 - zmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSave",687,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "D - 'Double_t' 10 - x", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetZmin",702,G__G__Hist_236_0_22, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetZmax",704,G__G__Hist_236_0_23, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Integral",822,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - a d - 'Double_t' 0 - b "
"D - 'Double_t' 10 '0' params d - 'Double_t' 0 '0.000001' epsilon", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Integral",822,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 0, 
"d - 'Double_t' 0 - ax d - 'Double_t' 0 - bx "
"d - 'Double_t' 0 - ay d - 'Double_t' 0 - by "
"d - 'Double_t' 0 '0.000001' epsilon", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Integral",822,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 7, 1, 1, 0, 
"d - 'Double_t' 0 - ax d - 'Double_t' 0 - bx "
"d - 'Double_t' 0 - ay d - 'Double_t' 0 - by "
"d - 'Double_t' 0 - az d - 'Double_t' 0 - bz "
"d - 'Double_t' 0 '0.000001' epsilon", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsInside",792,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "D - 'Double_t' 10 - x", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateHistogram",1538,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TH1), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Save",399,(G__InterfaceMethod) NULL,121, -1, -1, 0, 6, 1, 1, 0, 
"d - 'Double_t' 0 - xmin d - 'Double_t' 0 - xmax "
"d - 'Double_t' 0 - ymin d - 'Double_t' 0 - ymax "
"d - 'Double_t' 0 - zmin d - 'Double_t' 0 - zmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetClippingBoxOff",1702,G__G__Hist_236_0_32, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetClippingBoxOn",1608,G__G__Hist_236_0_33, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 '0' xclip d - 'Double_t' 0 '0' yclip "
"d - 'Double_t' 0 '0' zclip", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetNpz",612,G__G__Hist_236_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '30' npz", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetRange",793,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - xmin d - 'Double_t' 0 - xmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetRange",793,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - xmin d - 'Double_t' 0 - ymin "
"d - 'Double_t' 0 - xmax d - 'Double_t' 0 - ymax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetRange",793,(G__InterfaceMethod) NULL,121, -1, -1, 0, 6, 1, 1, 0, 
"d - 'Double_t' 0 - xmin d - 'Double_t' 0 - ymin "
"d - 'Double_t' 0 - zmin d - 'Double_t' 0 - xmax "
"d - 'Double_t' 0 - ymax d - 'Double_t' 0 - zmax", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Moment3",675,G__G__Hist_236_0_38, 100, -1, G__defined_typename("Double_t"), 0, 10, 1, 1, 0, 
"d - 'Double_t' 0 - nx d - 'Double_t' 0 - ax "
"d - 'Double_t' 0 - bx d - 'Double_t' 0 - ny "
"d - 'Double_t' 0 - ay d - 'Double_t' 0 - by "
"d - 'Double_t' 0 - nz d - 'Double_t' 0 - az "
"d - 'Double_t' 0 - bz d - 'Double_t' 0 '0.000001' epsilon", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CentralMoment3",1388,G__G__Hist_236_0_39, 100, -1, G__defined_typename("Double_t"), 0, 10, 1, 1, 0, 
"d - 'Double_t' 0 - nx d - 'Double_t' 0 - ax "
"d - 'Double_t' 0 - bx d - 'Double_t' 0 - ny "
"d - 'Double_t' 0 - ay d - 'Double_t' 0 - by "
"d - 'Double_t' 0 - nz d - 'Double_t' 0 - az "
"d - 'Double_t' 0 - bz d - 'Double_t' 0 '0.000001' epsilon", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Mean3X",524,G__G__Hist_236_0_40, 100, -1, G__defined_typename("Double_t"), 0, 7, 1, 1, 0, 
"d - 'Double_t' 0 - ax d - 'Double_t' 0 - bx "
"d - 'Double_t' 0 - ay d - 'Double_t' 0 - by "
"d - 'Double_t' 0 - az d - 'Double_t' 0 - bz "
"d - 'Double_t' 0 '0.000001' epsilon", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Mean3Y",525,G__G__Hist_236_0_41, 100, -1, G__defined_typename("Double_t"), 0, 7, 1, 1, 0, 
"d - 'Double_t' 0 - ax d - 'Double_t' 0 - bx "
"d - 'Double_t' 0 - ay d - 'Double_t' 0 - by "
"d - 'Double_t' 0 - az d - 'Double_t' 0 - bz "
"d - 'Double_t' 0 '0.000001' epsilon", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Mean3Z",526,G__G__Hist_236_0_42, 100, -1, G__defined_typename("Double_t"), 0, 7, 1, 1, 0, 
"d - 'Double_t' 0 - ax d - 'Double_t' 0 - bx "
"d - 'Double_t' 0 - ay d - 'Double_t' 0 - by "
"d - 'Double_t' 0 - az d - 'Double_t' 0 - bz "
"d - 'Double_t' 0 '0.000001' epsilon", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Variance3X",948,G__G__Hist_236_0_43, 100, -1, G__defined_typename("Double_t"), 0, 7, 1, 1, 0, 
"d - 'Double_t' 0 - ax d - 'Double_t' 0 - bx "
"d - 'Double_t' 0 - ay d - 'Double_t' 0 - by "
"d - 'Double_t' 0 - az d - 'Double_t' 0 - bz "
"d - 'Double_t' 0 '0.000001' epsilon", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Variance3Y",949,G__G__Hist_236_0_44, 100, -1, G__defined_typename("Double_t"), 0, 7, 1, 1, 0, 
"d - 'Double_t' 0 - ax d - 'Double_t' 0 - bx "
"d - 'Double_t' 0 - ay d - 'Double_t' 0 - by "
"d - 'Double_t' 0 - az d - 'Double_t' 0 - bz "
"d - 'Double_t' 0 '0.000001' epsilon", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Variance3Z",950,G__G__Hist_236_0_45, 100, -1, G__defined_typename("Double_t"), 0, 7, 1, 1, 0, 
"d - 'Double_t' 0 - ax d - 'Double_t' 0 - bx "
"d - 'Double_t' 0 - ay d - 'Double_t' 0 - by "
"d - 'Double_t' 0 - az d - 'Double_t' 0 - bz "
"d - 'Double_t' 0 '0.000001' epsilon", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Covariance3XY",1247,G__G__Hist_236_0_46, 100, -1, G__defined_typename("Double_t"), 0, 7, 1, 1, 0, 
"d - 'Double_t' 0 - ax d - 'Double_t' 0 - bx "
"d - 'Double_t' 0 - ay d - 'Double_t' 0 - by "
"d - 'Double_t' 0 - az d - 'Double_t' 0 - bz "
"d - 'Double_t' 0 '0.000001' epsilon", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Covariance3XZ",1248,G__G__Hist_236_0_47, 100, -1, G__defined_typename("Double_t"), 0, 7, 1, 1, 0, 
"d - 'Double_t' 0 - ax d - 'Double_t' 0 - bx "
"d - 'Double_t' 0 - ay d - 'Double_t' 0 - by "
"d - 'Double_t' 0 - az d - 'Double_t' 0 - bz "
"d - 'Double_t' 0 '0.000001' epsilon", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Covariance3YZ",1249,G__G__Hist_236_0_48, 100, -1, G__defined_typename("Double_t"), 0, 7, 1, 1, 0, 
"d - 'Double_t' 0 - ax d - 'Double_t' 0 - bx "
"d - 'Double_t' 0 - ay d - 'Double_t' 0 - by "
"d - 'Double_t' 0 - az d - 'Double_t' 0 - bz "
"d - 'Double_t' 0 '0.000001' epsilon", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Hist_236_0_49, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TF3::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_236_0_50, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TF3::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_236_0_51, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TF3::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_236_0_52, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TF3::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_236_0_56, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_236_0_57, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TF3::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_236_0_58, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TF3::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_236_0_59, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TF3::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_236_0_60, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TF3::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TF3", 331, G__G__Hist_236_0_61, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTFractionFitter(void) {
   /* TFractionFitter */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TFractionFitter));
   G__memfunc_setup("TFractionFitter",1528,G__G__Hist_272_0_1, 105, G__get_linked_tagnum(&G__G__HistLN_TFractionFitter), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TFractionFitter",1528,G__G__Hist_272_0_2, 105, G__get_linked_tagnum(&G__G__HistLN_TFractionFitter), -1, 0, 2, 1, 1, 0, 
"U 'TH1' - 0 - data U 'TObjArray' - 0 - MCs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFitter",910,G__G__Hist_272_0_3, 85, G__get_linked_tagnum(&G__G__HistLN_TVirtualFitter), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ErrorAnalysis",1358,G__G__Hist_272_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - UP", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRangeX",881,G__G__Hist_272_0_5, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - low i - 'Int_t' 0 - high", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReleaseRangeX",1286,G__G__Hist_272_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRangeY",882,G__G__Hist_272_0_7, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - low i - 'Int_t' 0 - high", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReleaseRangeY",1287,G__G__Hist_272_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRangeZ",883,G__G__Hist_272_0_9, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - low i - 'Int_t' 0 - high", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReleaseRangeZ",1288,G__G__Hist_272_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Constrain",945,G__G__Hist_272_0_11, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - parm d - 'Double_t' 0 - low "
"d - 'Double_t' 0 - high", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UnConstrain",1140,G__G__Hist_272_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - parm", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetData",678,G__G__Hist_272_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TH1' - 0 - data", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMC",444,G__G__Hist_272_0_14, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - parm U 'TH1' - 0 - MC", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetWeight",916,G__G__Hist_272_0_15, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - parm U 'TH1' - 0 - weight", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Fit",291,G__G__Hist_272_0_16, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetResult",927,G__G__Hist_272_0_17, 121, -1, -1, 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - parm d - 'Double_t' 1 - value "
"d - 'Double_t' 1 - error", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPlot",703,G__G__Hist_272_0_18, 85, G__get_linked_tagnum(&G__G__HistLN_TH1), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetChisquare",1221,G__G__Hist_272_0_19, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNDF",504,G__G__Hist_272_0_20, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetProb",691,G__G__Hist_272_0_21, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMCPrediction",1473,G__G__Hist_272_0_22, 85, G__get_linked_tagnum(&G__G__HistLN_TH1), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - parm", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckParNo",958,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 8, "i - 'Int_t' 0 - parm", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckConsistency",1648,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindPrediction",1426,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 5, 1, 4, 8, 
"i - - 0 - bin D - - 0 - fractions "
"d - - 1 - Ti i - - 1 - k0 "
"d - - 1 - Aki", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ComputeFCN",948,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 5, 1, 4, 0, 
"i - 'Int_t' 1 - npar D - 'Double_t' 0 - gin "
"d - 'Double_t' 1 - f D - 'Double_t' 0 - par "
"i - 'Int_t' 0 - flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRanges",896,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 6, 1, 4, 8, 
"i - 'Int_t' 1 - minX i - 'Int_t' 1 - maxX "
"i - 'Int_t' 1 - minY i - 'Int_t' 1 - maxY "
"i - 'Int_t' 1 - minZ i - 'Int_t' 1 - maxZ", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ComputeChisquareLambda",2243,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Hist_272_0_29, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TFractionFitter::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_272_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFractionFitter::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_272_0_31, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TFractionFitter::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_272_0_32, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TFractionFitter::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_272_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_272_0_37, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFractionFitter::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_272_0_38, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TFractionFitter::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_272_0_39, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFractionFitter::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_272_0_40, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TFractionFitter::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TFractionFitter", 1654, G__G__Hist_272_0_41, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTVirtualHistPainter(void) {
   /* TVirtualHistPainter */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TVirtualHistPainter));
   G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("DrawPanel",894,G__G__Hist_273_0_3, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetContourList",1446,G__G__Hist_273_0_5, 85, G__get_linked_tagnum(&G__G__HistLN_TList), -1, 0, 1, 1, 1, 8, "d - 'Double_t' 0 - contour", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetObjectInfo",1283,(G__InterfaceMethod) NULL,67, -1, -1, 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetStack",790,G__G__Hist_273_0_7, 85, G__get_linked_tagnum(&G__G__HistLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("IsInside",792,G__G__Hist_273_0_8, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - x i - 'Int_t' 0 - y", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("IsInside",792,G__G__Hist_273_0_9, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("PaintStat",920,G__G__Hist_273_0_11, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - dostat U 'TF1' - 0 - fit", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ProcessMessage",1444,G__G__Hist_273_0_12, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - mess U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetHistogram",1242,G__G__Hist_273_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TH1' - 0 - h", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetStack",802,G__G__Hist_273_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TList' - 0 - stack", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("MakeCuts",797,G__G__Hist_273_0_15, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - - 0 - cutsopt", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetShowProjection",1770,G__G__Hist_273_0_16, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - option i - 'Int_t' 0 - nbins", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("HistPainter",1131,G__G__Hist_273_0_17, 85, G__get_linked_tagnum(&G__G__HistLN_TVirtualHistPainter), -1, 0, 1, 3, 1, 0, "U 'TH1' - 0 - obj", (char*)NULL, (void*) G__func2void( (TVirtualHistPainter* (*)(TH1*))(&TVirtualHistPainter::HistPainter) ), 0);
   G__memfunc_setup("SetPainter",1023,G__G__Hist_273_0_18, 121, -1, -1, 0, 1, 3, 1, 0, "C - - 10 - painter", (char*)NULL, (void*) G__func2void( (void (*)(const char*))(&TVirtualHistPainter::SetPainter) ), 0);
   G__memfunc_setup("Class",502,G__G__Hist_273_0_19, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TVirtualHistPainter::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_273_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualHistPainter::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_273_0_21, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TVirtualHistPainter::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_273_0_22, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TVirtualHistPainter::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_273_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_273_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualHistPainter::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_273_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TVirtualHistPainter::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_273_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualHistPainter::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_273_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TVirtualHistPainter::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TVirtualHistPainter", 2084, G__G__Hist_273_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Hist_273_0_32, (int) ('u'), G__get_linked_tagnum(&G__G__HistLN_TVirtualHistPainter), -1, 1, 1, 1, 1, 0, "u 'TVirtualHistPainter' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTH2D(void) {
   /* TH2D */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TH2D));
   G__memfunc_setup("TH2D",274,G__G__Hist_274_0_1, 105, G__get_linked_tagnum(&G__G__HistLN_TH2D), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH2D",274,G__G__Hist_274_0_2, 105, G__get_linked_tagnum(&G__G__HistLN_TH2D), -1, 0, 8, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx d - 'Double_t' 0 - xlow "
"d - 'Double_t' 0 - xup i - 'Int_t' 0 - nbinsy "
"d - 'Double_t' 0 - ylow d - 'Double_t' 0 - yup", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH2D",274,G__G__Hist_274_0_3, 105, G__get_linked_tagnum(&G__G__HistLN_TH2D), -1, 0, 7, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx D - 'Double_t' 10 - xbins "
"i - 'Int_t' 0 - nbinsy d - 'Double_t' 0 - ylow "
"d - 'Double_t' 0 - yup", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH2D",274,G__G__Hist_274_0_4, 105, G__get_linked_tagnum(&G__G__HistLN_TH2D), -1, 0, 7, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx d - 'Double_t' 0 - xlow "
"d - 'Double_t' 0 - xup i - 'Int_t' 0 - nbinsy "
"D - 'Double_t' 10 - ybins", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH2D",274,G__G__Hist_274_0_5, 105, G__get_linked_tagnum(&G__G__HistLN_TH2D), -1, 0, 6, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx D - 'Double_t' 10 - xbins "
"i - 'Int_t' 0 - nbinsy D - 'Double_t' 10 - ybins", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH2D",274,G__G__Hist_274_0_6, 105, G__get_linked_tagnum(&G__G__HistLN_TH2D), -1, 0, 6, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx F - 'Float_t' 10 - xbins "
"i - 'Int_t' 0 - nbinsy F - 'Float_t' 10 - ybins", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH2D",274,G__G__Hist_274_0_7, 105, G__get_linked_tagnum(&G__G__HistLN_TH2D), -1, 0, 1, 1, 1, 0, "u 'TMatrixTBase<double>' 'TMatrixDBase' 11 - m", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH2D",274,G__G__Hist_274_0_8, 105, G__get_linked_tagnum(&G__G__HistLN_TH2D), -1, 0, 1, 1, 1, 0, "u 'TH2D' - 11 - h2d", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddBinContent",1277,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddBinContent",1277,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - bin d - 'Double_t' 0 - w", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TObject' - 1 - hnew", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawCopy",809,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TH1), -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinContent",1300,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinContent",1300,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - binx i - 'Int_t' 0 - biny", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinContent",1300,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - binx i - 'Int_t' 0 - biny "
"i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Reset",515,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinContent",1312,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - bin d - 'Double_t' 0 - content", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinContent",1312,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - binx i - 'Int_t' 0 - biny "
"d - 'Double_t' 0 - content", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinContent",1312,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - binx i - 'Int_t' 0 - biny "
"i - 'Int_t' 0 - - d - 'Double_t' 0 - content", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinsLength",1306,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '-1' n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator=",937,G__G__Hist_274_0_21, 117, G__get_linked_tagnum(&G__G__HistLN_TH2D), -1, 1, 1, 1, 1, 0, "u 'TH2D' - 11 - h1", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Hist_274_0_22, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TH2D::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_274_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH2D::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_274_0_24, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TH2D::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_274_0_25, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TH2D::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_274_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_274_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH2D::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_274_0_31, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TH2D::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_274_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH2D::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_274_0_33, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TH2D::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TH2D", 400, G__G__Hist_274_0_34, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGraph2DErrors(void) {
   /* TGraph2DErrors */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TGraph2DErrors));
   G__memfunc_setup("TGraph2DErrors",1337,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__HistLN_TGraph2DErrors), -1, 0, 1, 1, 4, 0, "u 'TGraph2DErrors' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__HistLN_TGraph2DErrors), -1, 1, 1, 1, 4, 0, "u 'TGraph2DErrors' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TGraph2DErrors",1337,G__G__Hist_276_0_3, 105, G__get_linked_tagnum(&G__G__HistLN_TGraph2DErrors), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGraph2DErrors",1337,G__G__Hist_276_0_4, 105, G__get_linked_tagnum(&G__G__HistLN_TGraph2DErrors), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGraph2DErrors",1337,G__G__Hist_276_0_5, 105, G__get_linked_tagnum(&G__G__HistLN_TGraph2DErrors), -1, 0, 8, 1, 1, 0, 
"i - 'Int_t' 0 - n D - 'Double_t' 0 - x "
"D - 'Double_t' 0 - y D - 'Double_t' 0 - z "
"D - 'Double_t' 0 '0' ex D - 'Double_t' 0 '0' ey "
"D - 'Double_t' 0 '0' ez C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetErrorX",898,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetErrorY",899,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetErrorZ",900,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEX",445,(G__InterfaceMethod) NULL,68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEY",446,(G__InterfaceMethod) NULL,68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEZ",447,(G__InterfaceMethod) NULL,68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetXmaxE",771,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetXminE",769,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetYmaxE",772,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetYminE",770,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetZmaxE",773,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetZminE",771,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Set",300,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPoint",822,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - i d - 'Double_t' 0 - x "
"d - 'Double_t' 0 - y d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPointError",1344,G__G__Hist_276_0_20, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - i d - 'Double_t' 0 - ex "
"d - 'Double_t' 0 - ey d - 'Double_t' 0 - ez", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Hist_276_0_21, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGraph2DErrors::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_276_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGraph2DErrors::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_276_0_23, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGraph2DErrors::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_276_0_24, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGraph2DErrors::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_276_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_276_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGraph2DErrors::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_276_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGraph2DErrors::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_276_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGraph2DErrors::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_276_0_32, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGraph2DErrors::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGraph2DErrors", 1463, G__G__Hist_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_memfuncTH1F(void) {
   /* TH1F */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TH1F));
   G__memfunc_setup("TH1F",275,G__G__Hist_277_0_1, 105, G__get_linked_tagnum(&G__G__HistLN_TH1F), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH1F",275,G__G__Hist_277_0_2, 105, G__get_linked_tagnum(&G__G__HistLN_TH1F), -1, 0, 5, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx d - 'Double_t' 0 - xlow "
"d - 'Double_t' 0 - xup", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH1F",275,G__G__Hist_277_0_3, 105, G__get_linked_tagnum(&G__G__HistLN_TH1F), -1, 0, 4, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx F - 'Float_t' 10 - xbins", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH1F",275,G__G__Hist_277_0_4, 105, G__get_linked_tagnum(&G__G__HistLN_TH1F), -1, 0, 4, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx D - 'Double_t' 10 - xbins", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH1F",275,G__G__Hist_277_0_5, 105, G__get_linked_tagnum(&G__G__HistLN_TH1F), -1, 0, 1, 1, 1, 0, "u 'TVectorT<float>' 'TVectorF' 11 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH1F",275,G__G__Hist_277_0_6, 105, G__get_linked_tagnum(&G__G__HistLN_TH1F), -1, 0, 1, 1, 1, 0, "u 'TH1F' - 11 - h1f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddBinContent",1277,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddBinContent",1277,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - bin d - 'Double_t' 0 - w", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TObject' - 1 - hnew", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawCopy",809,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TH1), -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinContent",1300,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinContent",1300,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - bin i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinContent",1300,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - bin i - 'Int_t' 0 - - "
"i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Reset",515,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinContent",1312,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - bin d - 'Double_t' 0 - content", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinContent",1312,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - bin i - 'Int_t' 0 - - "
"d - 'Double_t' 0 - content", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinContent",1312,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - bin i - 'Int_t' 0 - - "
"i - 'Int_t' 0 - - d - 'Double_t' 0 - content", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinsLength",1306,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '-1' n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator=",937,G__G__Hist_277_0_19, 117, G__get_linked_tagnum(&G__G__HistLN_TH1F), -1, 1, 1, 1, 1, 0, "u 'TH1F' - 11 - h1", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Hist_277_0_20, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TH1F::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_277_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH1F::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_277_0_22, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TH1F::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_277_0_23, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TH1F::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_277_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_277_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH1F::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_277_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TH1F::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_277_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH1F::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_277_0_31, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TH1F::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TH1F", 401, G__G__Hist_277_0_32, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTSpline(void) {
   /* TSpline */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TSpline));
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__HistLN_TSpline), -1, 1, 1, 1, 2, 0, "u 'TSpline' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BuildCoeff",979,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetKnot",700,G__G__Hist_278_0_6, 121, -1, -1, 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - i d - 'Double_t' 1 - x "
"d - 'Double_t' 1 - y", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDelta",778,G__G__Hist_278_0_10, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetHistogram",1230,G__G__Hist_278_0_11, 85, G__get_linked_tagnum(&G__G__HistLN_TH1F), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNp",478,G__G__Hist_278_0_12, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNpx",598,G__G__Hist_278_0_13, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetXmin",700,G__G__Hist_278_0_14, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetXmax",702,G__G__Hist_278_0_15, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Eval",392,G__G__Hist_278_0_17, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "d - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SaveAs",579,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 8, 
"C - - 10 - - C - 'Option_t' 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetNpx",610,G__G__Hist_278_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Hist_278_0_20, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TSpline::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_278_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSpline::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_278_0_22, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TSpline::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_278_0_23, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TSpline::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_278_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_278_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSpline::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_278_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSpline::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_278_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSpline::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_278_0_31, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSpline::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TSpline", 829, G__G__Hist_278_0_32, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGraphBentErrors(void) {
   /* TGraphBentErrors */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TGraphBentErrors));
   G__memfunc_setup("SwapPoints",1048,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"i - 'Int_t' 0 - pos1 i - 'Int_t' 0 - pos2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Allocate",805,(G__InterfaceMethod) NULL, 68, -1, G__defined_typename("Double_t"), 2, 1, 1, 2, 0, "i - 'Int_t' 0 - size", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CopyAndRelease",1391,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 2, 0, 
"D - 'Double_t' 2 - newarrays i - 'Int_t' 0 - ibegin "
"i - 'Int_t' 0 - iend i - 'Int_t' 0 - obegin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CopyPoints",1048,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 2, 0, 
"D - 'Double_t' 2 - arrays i - 'Int_t' 0 - ibegin "
"i - 'Int_t' 0 - iend i - 'Int_t' 0 - obegin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CtorAllocate",1213,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FillZero",807,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"i - 'Int_t' 0 - begin i - 'Int_t' 0 - end "
"g - 'Bool_t' 0 'kTRUE' from_ctor", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TGraphBentErrors",1612,G__G__Hist_280_0_7, 105, G__get_linked_tagnum(&G__G__HistLN_TGraphBentErrors), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGraphBentErrors",1612,G__G__Hist_280_0_8, 105, G__get_linked_tagnum(&G__G__HistLN_TGraphBentErrors), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGraphBentErrors",1612,G__G__Hist_280_0_9, 105, G__get_linked_tagnum(&G__G__HistLN_TGraphBentErrors), -1, 0, 11, 1, 1, 0, 
"i - 'Int_t' 0 - n F - 'Float_t' 10 - x "
"F - 'Float_t' 10 - y F - 'Float_t' 10 '0' exl "
"F - 'Float_t' 10 '0' exh F - 'Float_t' 10 '0' eyl "
"F - 'Float_t' 10 '0' eyh F - 'Float_t' 10 '0' exld "
"F - 'Float_t' 10 '0' exhd F - 'Float_t' 10 '0' eyld "
"F - 'Float_t' 10 '0' eyhd", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGraphBentErrors",1612,G__G__Hist_280_0_10, 105, G__get_linked_tagnum(&G__G__HistLN_TGraphBentErrors), -1, 0, 11, 1, 1, 0, 
"i - 'Int_t' 0 - n D - 'Double_t' 10 - x "
"D - 'Double_t' 10 - y D - 'Double_t' 10 '0' exl "
"D - 'Double_t' 10 '0' exh D - 'Double_t' 10 '0' eyl "
"D - 'Double_t' 10 '0' eyh D - 'Double_t' 10 '0' exld "
"D - 'Double_t' 10 '0' exhd D - 'Double_t' 10 '0' eyld "
"D - 'Double_t' 10 '0' eyhd", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGraphBentErrors",1612,G__G__Hist_280_0_11, 105, G__get_linked_tagnum(&G__G__HistLN_TGraphBentErrors), -1, 0, 1, 1, 1, 0, "u 'TGraphBentErrors' - 11 - gr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Apply",518,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TF1' - 0 - f", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ComputeRange",1226,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 8, 
"d - 'Double_t' 1 - xmin d - 'Double_t' 1 - ymin "
"d - 'Double_t' 1 - xmax d - 'Double_t' 1 - ymax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetErrorX",898,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetErrorY",899,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetErrorXlow",1236,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetErrorXhigh",1314,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetErrorYlow",1237,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetErrorYhigh",1315,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEXlow",783,(G__InterfaceMethod) NULL,68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEXhigh",861,(G__InterfaceMethod) NULL,68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEYlow",784,(G__InterfaceMethod) NULL,68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEYhigh",862,(G__InterfaceMethod) NULL,68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEXlowd",883,(G__InterfaceMethod) NULL,68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEXhighd",961,(G__InterfaceMethod) NULL,68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEYlowd",884,(G__InterfaceMethod) NULL,68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEYhighd",962,(G__InterfaceMethod) NULL,68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' chopt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPointError",1344,G__G__Hist_280_0_30, 121, -1, -1, 0, 8, 1, 1, 0, 
"d - 'Double_t' 0 - exl d - 'Double_t' 0 - exh "
"d - 'Double_t' 0 - eyl d - 'Double_t' 0 - eyh "
"d - 'Double_t' 0 '0' exld d - 'Double_t' 0 '0' exhd "
"d - 'Double_t' 0 '0' eyld d - 'Double_t' 0 '0' eyhd", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetPointError",1344,G__G__Hist_280_0_31, 121, -1, -1, 0, 9, 1, 1, 0, 
"i - 'Int_t' 0 - i d - 'Double_t' 0 - exl "
"d - 'Double_t' 0 - exh d - 'Double_t' 0 - eyl "
"d - 'Double_t' 0 - eyh d - 'Double_t' 0 '0' exld "
"d - 'Double_t' 0 '0' exhd d - 'Double_t' 0 '0' eyld "
"d - 'Double_t' 0 '0' eyhd", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Hist_280_0_32, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGraphBentErrors::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_280_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGraphBentErrors::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_280_0_34, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGraphBentErrors::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_280_0_35, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGraphBentErrors::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_280_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_280_0_40, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGraphBentErrors::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_280_0_41, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGraphBentErrors::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_280_0_42, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGraphBentErrors::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_280_0_43, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGraphBentErrors::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGraphBentErrors", 1738, G__G__Hist_280_0_44, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Hist_280_0_45, (int) ('u'), G__get_linked_tagnum(&G__G__HistLN_TGraphBentErrors), -1, 1, 1, 1, 1, 0, "u 'TGraphBentErrors' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGraphDelaunay(void) {
   /* TGraphDelaunay */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TGraphDelaunay));
   G__memfunc_setup("TGraphDelaunay",1401,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__HistLN_TGraphDelaunay), -1, 0, 1, 1, 4, 0, "u 'TGraphDelaunay' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__HistLN_TGraphDelaunay), -1, 1, 1, 1, 4, 0, "u 'TGraphDelaunay' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("CreateTrianglesDataStructure",2888,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Enclose",713,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 2, 8, 
"i - 'Int_t' 0 - T1 i - 'Int_t' 0 - T2 "
"i - 'Int_t' 0 - T3 i - 'Int_t' 0 - Ex", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FileIt",573,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"i - 'Int_t' 0 - P i - 'Int_t' 0 - N "
"i - 'Int_t' 0 - M", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindHull",790,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InHull",588,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 2, 8, 
"i - 'Int_t' 0 - E i - 'Int_t' 0 - X", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InterpolateOnPlane",1844,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 4, 1, 2, 8, 
"i - 'Int_t' 0 - TI1 i - 'Int_t' 0 - TI2 "
"i - 'Int_t' 0 - TI3 i - 'Int_t' 0 - E", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGraphDelaunay",1401,G__G__Hist_281_0_9, 105, G__get_linked_tagnum(&G__G__HistLN_TGraphDelaunay), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGraphDelaunay",1401,G__G__Hist_281_0_10, 105, G__get_linked_tagnum(&G__G__HistLN_TGraphDelaunay), -1, 0, 1, 1, 1, 0, "U 'TGraph2D' - 0 - g", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ComputeZ",823,G__G__Hist_281_0_11, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindAllTriangles",1603,G__G__Hist_281_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGraph2D",904,G__G__Hist_281_0_13, 85, G__get_linked_tagnum(&G__G__HistLN_TGraph2D), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMarginBinsContent",2021,G__G__Hist_281_0_14, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNdt",582,G__G__Hist_281_0_15, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPTried",872,G__G__Hist_281_0_16, 73, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNTried",870,G__G__Hist_281_0_17, 73, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMTried",869,G__G__Hist_281_0_18, 73, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetXN",454,G__G__Hist_281_0_19, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetYN",455,G__G__Hist_281_0_20, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetXNmin",778,G__G__Hist_281_0_21, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetXNmax",780,G__G__Hist_281_0_22, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetYNmin",779,G__G__Hist_281_0_23, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetYNmax",781,G__G__Hist_281_0_24, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Interpolate",1159,G__G__Hist_281_0_25, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMaxIter",998,G__G__Hist_281_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '100000' n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMarginBinsContent",2033,G__G__Hist_281_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 '0.' z", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Hist_281_0_28, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGraphDelaunay::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_281_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGraphDelaunay::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_281_0_30, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGraphDelaunay::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_281_0_31, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGraphDelaunay::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_281_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_281_0_36, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGraphDelaunay::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_281_0_37, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGraphDelaunay::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_281_0_38, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGraphDelaunay::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_281_0_39, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGraphDelaunay::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGraphDelaunay", 1527, G__G__Hist_281_0_40, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGraphSmooth(void) {
   /* TGraphSmooth */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TGraphSmooth));
   G__memfunc_setup("TGraphSmooth",1216,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__HistLN_TGraphSmooth), -1, 0, 1, 1, 4, 0, "u 'TGraphSmooth' - 11 - -", "Not implented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__HistLN_TGraphSmooth), -1, 1, 1, 1, 4, 0, "u 'TGraphSmooth' - 11 - -", "Not implented", (void*) NULL, 0);
   G__memfunc_setup("TGraphSmooth",1216,G__G__Hist_282_0_3, 105, G__get_linked_tagnum(&G__G__HistLN_TGraphSmooth), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGraphSmooth",1216,G__G__Hist_282_0_4, 105, G__get_linked_tagnum(&G__G__HistLN_TGraphSmooth), -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Approx",634,G__G__Hist_282_0_5, 85, G__get_linked_tagnum(&G__G__HistLN_TGraph), -1, 0, 9, 1, 1, 0, 
"U 'TGraph' - 0 - grin C - 'Option_t' 10 '\"linear\"' option "
"i - 'Int_t' 0 '50' nout D - 'Double_t' 0 '0' xout "
"d - 'Double_t' 0 '0' yleft d - 'Double_t' 0 '0' yright "
"i - 'Int_t' 0 '0' rule d - 'Double_t' 0 '0' f "
"C - 'Option_t' 10 '\"mean\"' ties", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SmoothKern",1034,G__G__Hist_282_0_6, 85, G__get_linked_tagnum(&G__G__HistLN_TGraph), -1, 0, 5, 1, 1, 0, 
"U 'TGraph' - 0 - grin C - 'Option_t' 10 '\"normal\"' option "
"d - 'Double_t' 0 '0.5' bandwidth i - 'Int_t' 0 '100' nout "
"D - 'Double_t' 0 '0' xout", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SmoothLowess",1271,G__G__Hist_282_0_7, 85, G__get_linked_tagnum(&G__G__HistLN_TGraph), -1, 0, 5, 1, 1, 0, 
"U 'TGraph' - 0 - grin C - 'Option_t' 10 '\"\"' option "
"d - 'Double_t' 0 '0.67' span i - 'Int_t' 0 '3' iter "
"d - 'Double_t' 0 '0' delta", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SmoothSuper",1161,G__G__Hist_282_0_8, 85, G__get_linked_tagnum(&G__G__HistLN_TGraph), -1, 0, 6, 1, 1, 0, 
"U 'TGraph' - 0 - grin C - 'Option_t' 10 '\"\"' option "
"d - 'Double_t' 0 '0' bass d - 'Double_t' 0 '0' span "
"g - 'Bool_t' 0 'kFALSE' isPeriodic D - 'Double_t' 0 '0' w", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Approxin",849,G__G__Hist_282_0_9, 121, -1, -1, 0, 6, 1, 1, 0, 
"U 'TGraph' - 0 - grin i - 'Int_t' 0 - iKind "
"d - 'Double_t' 1 - Ylow d - 'Double_t' 1 - Yhigh "
"i - 'Int_t' 0 - rule i - 'Int_t' 0 - iTies", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Smoothin",849,G__G__Hist_282_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGraph' - 0 - grin", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Approx1",683,G__G__Hist_282_0_11, 100, -1, G__defined_typename("Double_t"), 0, 8, 3, 1, 0, 
"d - 'Double_t' 0 - v d - 'Double_t' 0 - f "
"D - 'Double_t' 0 - x D - 'Double_t' 0 - y "
"i - 'Int_t' 0 - n i - 'Int_t' 0 - iKind "
"d - 'Double_t' 0 - Ylow d - 'Double_t' 0 - Yhigh", (char*)NULL, (void*) G__func2void( (Double_t (*)(Double_t, Double_t, Double_t*, Double_t*, Int_t, Int_t, Double_t, Double_t))(&TGraphSmooth::Approx1) ), 0);
   G__memfunc_setup("Lowess",637,G__G__Hist_282_0_12, 121, -1, -1, 0, 7, 1, 1, 0, 
"D - 'Double_t' 0 - x D - 'Double_t' 0 - y "
"i - 'Int_t' 0 - n D - 'Double_t' 0 - ys "
"d - 'Double_t' 0 - span i - 'Int_t' 0 - iter "
"d - 'Double_t' 0 - delta", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Lowest",638,G__G__Hist_282_0_13, 121, -1, -1, 0, 11, 3, 1, 0, 
"D - 'Double_t' 0 - x D - 'Double_t' 0 - y "
"i - 'Int_t' 0 - n d - 'Double_t' 1 - xs "
"d - 'Double_t' 1 - ys i - 'Int_t' 0 - nleft "
"i - 'Int_t' 0 - nright D - 'Double_t' 0 - w "
"g - 'Bool_t' 0 - userw D - 'Double_t' 0 - rw "
"g - 'Bool_t' 1 - ok", (char*)NULL, (void*) G__func2void( (void (*)(Double_t*, Double_t*, Int_t, Double_t&, Double_t&, Int_t, Int_t, Double_t*, Bool_t, Double_t*, Bool_t&))(&TGraphSmooth::Lowest) ), 0);
   G__memfunc_setup("Rcmp",402,G__G__Hist_282_0_14, 105, -1, G__defined_typename("Int_t"), 0, 2, 3, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y", (char*)NULL, (void*) G__func2void( (Int_t (*)(Double_t, Double_t))(&TGraphSmooth::Rcmp) ), 0);
   G__memfunc_setup("Psort",536,G__G__Hist_282_0_15, 121, -1, -1, 0, 3, 3, 1, 0, 
"D - 'Double_t' 0 - x i - 'Int_t' 0 - n "
"i - 'Int_t' 0 - k", (char*)NULL, (void*) G__func2void( (void (*)(Double_t*, Int_t, Int_t))(&TGraphSmooth::Psort) ), 0);
   G__memfunc_setup("Rank",396,G__G__Hist_282_0_16, 121, -1, -1, 0, 5, 3, 1, 0, 
"i - 'Int_t' 0 - n D - 'Double_t' 0 - a "
"I - 'Int_t' 0 - index I - 'Int_t' 0 - rank "
"g - 'Bool_t' 0 'kTRUE' down", (char*)NULL, (void*) G__func2void( (void (*)(Int_t, Double_t*, Int_t*, Int_t*, Bool_t))(&TGraphSmooth::Rank) ), 0);
   G__memfunc_setup("BDRksmooth",989,G__G__Hist_282_0_17, 121, -1, -1, 0, 8, 3, 1, 0, 
"D - 'Double_t' 0 - x D - 'Double_t' 0 - y "
"i - 'Int_t' 0 - n D - 'Double_t' 0 - xp "
"D - 'Double_t' 0 - yp i - 'Int_t' 0 - np "
"i - 'Int_t' 0 - kernel d - 'Double_t' 0 - bw", (char*)NULL, (void*) G__func2void( (void (*)(Double_t*, Double_t*, Int_t, Double_t*, Double_t*, Int_t, Int_t, Double_t))(&TGraphSmooth::BDRksmooth) ), 0);
   G__memfunc_setup("BDRsupsmu",901,G__G__Hist_282_0_18, 121, -1, -1, 0, 9, 3, 1, 0, 
"i - 'Int_t' 0 - n D - 'Double_t' 0 - x "
"D - 'Double_t' 0 - y D - 'Double_t' 0 - w "
"i - 'Int_t' 0 - iper d - 'Double_t' 0 - span "
"d - 'Double_t' 0 - alpha D - 'Double_t' 0 - smo "
"D - 'Double_t' 0 - sc", (char*)NULL, (void*) G__func2void( (void (*)(Int_t, Double_t*, Double_t*, Double_t*, Int_t, Double_t, Double_t, Double_t*, Double_t*))(&TGraphSmooth::BDRsupsmu) ), 0);
   G__memfunc_setup("BDRsmooth",882,G__G__Hist_282_0_19, 121, -1, -1, 0, 9, 3, 1, 0, 
"i - 'Int_t' 0 - n D - 'Double_t' 0 - x "
"D - 'Double_t' 0 - y D - 'Double_t' 0 - w "
"d - 'Double_t' 0 - span i - 'Int_t' 0 - iper "
"d - 'Double_t' 0 - vsmlsq D - 'Double_t' 0 - smo "
"D - 'Double_t' 0 - acvr", (char*)NULL, (void*) G__func2void( (void (*)(Int_t, Double_t*, Double_t*, Double_t*, Double_t, Int_t, Double_t, Double_t*, Double_t*))(&TGraphSmooth::BDRsmooth) ), 0);
   G__memfunc_setup("Class",502,G__G__Hist_282_0_20, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGraphSmooth::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_282_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGraphSmooth::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_282_0_22, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGraphSmooth::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_282_0_23, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGraphSmooth::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_282_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_282_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGraphSmooth::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_282_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGraphSmooth::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_282_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGraphSmooth::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_282_0_31, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGraphSmooth::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGraphSmooth", 1342, G__G__Hist_282_0_32, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGraphTime(void) {
   /* TGraphTime */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TGraphTime));
   G__memfunc_setup("TGraphTime",981,G__G__Hist_283_0_1, 105, G__get_linked_tagnum(&G__G__HistLN_TGraphTime), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGraphTime",981,G__G__Hist_283_0_2, 105, G__get_linked_tagnum(&G__G__HistLN_TGraphTime), -1, 0, 5, 1, 1, 0, 
"i - 'Int_t' 0 - nsteps d - 'Double_t' 0 - xmin "
"d - 'Double_t' 0 - ymin d - 'Double_t' 0 - xmax "
"d - 'Double_t' 0 - ymax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGraphTime",981,G__G__Hist_283_0_3, 105, G__get_linked_tagnum(&G__G__HistLN_TGraphTime), -1, 0, 1, 1, 1, 0, "u 'TGraphTime' - 11 - gr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Add",265,G__G__Hist_283_0_4, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"U 'TObject' - 10 - obj i - 'Int_t' 0 - slot "
"C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' chopt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSteps",815,G__G__Hist_283_0_6, 85, G__get_linked_tagnum(&G__G__HistLN_TObjArray), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' chopt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SaveAnimatedGif",1480,G__G__Hist_283_0_8, 121, -1, -1, 0, 1, 1, 1, 8, "C - - 10 '\"\"' filename", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetSleepTime",1204,G__G__Hist_283_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '0' stime", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Hist_283_0_10, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGraphTime::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_283_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGraphTime::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_283_0_12, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGraphTime::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_283_0_13, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGraphTime::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_283_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_283_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGraphTime::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_283_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGraphTime::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_283_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGraphTime::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_283_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGraphTime::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGraphTime", 1107, G__G__Hist_283_0_22, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Hist_283_0_23, (int) ('u'), G__get_linked_tagnum(&G__G__HistLN_TGraphTime), -1, 1, 1, 1, 1, 0, "u 'TGraphTime' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTH1D(void) {
   /* TH1D */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TH1D));
   G__memfunc_setup("TH1D",273,G__G__Hist_288_0_1, 105, G__get_linked_tagnum(&G__G__HistLN_TH1D), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH1D",273,G__G__Hist_288_0_2, 105, G__get_linked_tagnum(&G__G__HistLN_TH1D), -1, 0, 5, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx d - 'Double_t' 0 - xlow "
"d - 'Double_t' 0 - xup", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH1D",273,G__G__Hist_288_0_3, 105, G__get_linked_tagnum(&G__G__HistLN_TH1D), -1, 0, 4, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx F - 'Float_t' 10 - xbins", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH1D",273,G__G__Hist_288_0_4, 105, G__get_linked_tagnum(&G__G__HistLN_TH1D), -1, 0, 4, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx D - 'Double_t' 10 - xbins", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH1D",273,G__G__Hist_288_0_5, 105, G__get_linked_tagnum(&G__G__HistLN_TH1D), -1, 0, 1, 1, 1, 0, "u 'TVectorT<double>' 'TVectorD' 11 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH1D",273,G__G__Hist_288_0_6, 105, G__get_linked_tagnum(&G__G__HistLN_TH1D), -1, 0, 1, 1, 1, 0, "u 'TH1D' - 11 - h1d", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddBinContent",1277,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddBinContent",1277,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - bin d - 'Double_t' 0 - w", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TObject' - 1 - hnew", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawCopy",809,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TH1), -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinContent",1300,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinContent",1300,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - bin i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinContent",1300,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - bin i - 'Int_t' 0 - - "
"i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Reset",515,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinContent",1312,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - bin d - 'Double_t' 0 - content", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinContent",1312,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - bin i - 'Int_t' 0 - - "
"d - 'Double_t' 0 - content", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinContent",1312,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - bin i - 'Int_t' 0 - - "
"i - 'Int_t' 0 - - d - 'Double_t' 0 - content", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinsLength",1306,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '-1' n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator=",937,G__G__Hist_288_0_19, 117, G__get_linked_tagnum(&G__G__HistLN_TH1D), -1, 1, 1, 1, 1, 0, "u 'TH1D' - 11 - h1", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Hist_288_0_20, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TH1D::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_288_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH1D::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_288_0_22, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TH1D::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_288_0_23, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TH1D::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_288_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_288_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH1D::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_288_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TH1D::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_288_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH1D::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_288_0_31, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TH1D::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TH1D", 399, G__G__Hist_288_0_32, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTH1C(void) {
   /* TH1C */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TH1C));
   G__memfunc_setup("TH1C",272,G__G__Hist_291_0_1, 105, G__get_linked_tagnum(&G__G__HistLN_TH1C), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH1C",272,G__G__Hist_291_0_2, 105, G__get_linked_tagnum(&G__G__HistLN_TH1C), -1, 0, 5, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx d - 'Double_t' 0 - xlow "
"d - 'Double_t' 0 - xup", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH1C",272,G__G__Hist_291_0_3, 105, G__get_linked_tagnum(&G__G__HistLN_TH1C), -1, 0, 4, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx F - 'Float_t' 10 - xbins", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH1C",272,G__G__Hist_291_0_4, 105, G__get_linked_tagnum(&G__G__HistLN_TH1C), -1, 0, 4, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx D - 'Double_t' 10 - xbins", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH1C",272,G__G__Hist_291_0_5, 105, G__get_linked_tagnum(&G__G__HistLN_TH1C), -1, 0, 1, 1, 1, 0, "u 'TH1C' - 11 - h1c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddBinContent",1277,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddBinContent",1277,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - bin d - 'Double_t' 0 - w", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TObject' - 1 - hnew", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawCopy",809,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TH1), -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinContent",1300,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinContent",1300,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - bin i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinContent",1300,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - bin i - 'Int_t' 0 - - "
"i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Reset",515,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinContent",1312,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - bin d - 'Double_t' 0 - content", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinContent",1312,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - bin i - 'Int_t' 0 - - "
"d - 'Double_t' 0 - content", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinContent",1312,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - bin i - 'Int_t' 0 - - "
"i - 'Int_t' 0 - - d - 'Double_t' 0 - content", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinsLength",1306,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '-1' n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator=",937,G__G__Hist_291_0_18, 117, G__get_linked_tagnum(&G__G__HistLN_TH1C), -1, 1, 1, 1, 1, 0, "u 'TH1C' - 11 - h1", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Hist_291_0_19, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TH1C::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_291_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH1C::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_291_0_21, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TH1C::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_291_0_22, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TH1C::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_291_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_291_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH1C::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_291_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TH1C::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_291_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH1C::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_291_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TH1C::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TH1C", 398, G__G__Hist_291_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTH1S(void) {
   /* TH1S */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TH1S));
   G__memfunc_setup("TH1S",288,G__G__Hist_292_0_1, 105, G__get_linked_tagnum(&G__G__HistLN_TH1S), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH1S",288,G__G__Hist_292_0_2, 105, G__get_linked_tagnum(&G__G__HistLN_TH1S), -1, 0, 5, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx d - 'Double_t' 0 - xlow "
"d - 'Double_t' 0 - xup", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH1S",288,G__G__Hist_292_0_3, 105, G__get_linked_tagnum(&G__G__HistLN_TH1S), -1, 0, 4, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx F - 'Float_t' 10 - xbins", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH1S",288,G__G__Hist_292_0_4, 105, G__get_linked_tagnum(&G__G__HistLN_TH1S), -1, 0, 4, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx D - 'Double_t' 10 - xbins", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH1S",288,G__G__Hist_292_0_5, 105, G__get_linked_tagnum(&G__G__HistLN_TH1S), -1, 0, 1, 1, 1, 0, "u 'TH1S' - 11 - h1s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddBinContent",1277,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddBinContent",1277,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - bin d - 'Double_t' 0 - w", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TObject' - 1 - hnew", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawCopy",809,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TH1), -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinContent",1300,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinContent",1300,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - bin i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinContent",1300,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - bin i - 'Int_t' 0 - - "
"i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Reset",515,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinContent",1312,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - bin d - 'Double_t' 0 - content", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinContent",1312,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - bin i - 'Int_t' 0 - - "
"d - 'Double_t' 0 - content", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinContent",1312,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - bin i - 'Int_t' 0 - - "
"i - 'Int_t' 0 - - d - 'Double_t' 0 - content", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinsLength",1306,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '-1' n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator=",937,G__G__Hist_292_0_18, 117, G__get_linked_tagnum(&G__G__HistLN_TH1S), -1, 1, 1, 1, 1, 0, "u 'TH1S' - 11 - h1", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Hist_292_0_19, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TH1S::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_292_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH1S::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_292_0_21, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TH1S::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_292_0_22, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TH1S::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_292_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_292_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH1S::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_292_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TH1S::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_292_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH1S::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_292_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TH1S::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TH1S", 414, G__G__Hist_292_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTH1I(void) {
   /* TH1I */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TH1I));
   G__memfunc_setup("TH1I",278,G__G__Hist_293_0_1, 105, G__get_linked_tagnum(&G__G__HistLN_TH1I), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH1I",278,G__G__Hist_293_0_2, 105, G__get_linked_tagnum(&G__G__HistLN_TH1I), -1, 0, 5, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx d - 'Double_t' 0 - xlow "
"d - 'Double_t' 0 - xup", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH1I",278,G__G__Hist_293_0_3, 105, G__get_linked_tagnum(&G__G__HistLN_TH1I), -1, 0, 4, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx F - 'Float_t' 10 - xbins", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH1I",278,G__G__Hist_293_0_4, 105, G__get_linked_tagnum(&G__G__HistLN_TH1I), -1, 0, 4, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx D - 'Double_t' 10 - xbins", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH1I",278,G__G__Hist_293_0_5, 105, G__get_linked_tagnum(&G__G__HistLN_TH1I), -1, 0, 1, 1, 1, 0, "u 'TH1I' - 11 - h1i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddBinContent",1277,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddBinContent",1277,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - bin d - 'Double_t' 0 - w", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TObject' - 1 - hnew", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawCopy",809,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TH1), -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinContent",1300,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinContent",1300,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - bin i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinContent",1300,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - bin i - 'Int_t' 0 - - "
"i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Reset",515,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinContent",1312,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - bin d - 'Double_t' 0 - content", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinContent",1312,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - bin i - 'Int_t' 0 - - "
"d - 'Double_t' 0 - content", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinContent",1312,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - bin i - 'Int_t' 0 - - "
"i - 'Int_t' 0 - - d - 'Double_t' 0 - content", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinsLength",1306,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '-1' n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator=",937,G__G__Hist_293_0_18, 117, G__get_linked_tagnum(&G__G__HistLN_TH1I), -1, 1, 1, 1, 1, 0, "u 'TH1I' - 11 - h1", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Hist_293_0_19, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TH1I::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_293_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH1I::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_293_0_21, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TH1I::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_293_0_22, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TH1I::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_293_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_293_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH1I::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_293_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TH1I::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_293_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH1I::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_293_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TH1I::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TH1I", 404, G__G__Hist_293_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTH1K(void) {
   /* TH1K */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TH1K));
   G__memfunc_setup("Sort",424,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH1K",280,G__G__Hist_294_0_2, 105, G__get_linked_tagnum(&G__G__HistLN_TH1K), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH1K",280,G__G__Hist_294_0_3, 105, G__get_linked_tagnum(&G__G__HistLN_TH1K), -1, 0, 6, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx d - 'Double_t' 0 - xlow "
"d - 'Double_t' 0 - xup i - 'Int_t' 0 '0' k", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Fill",391,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Fill",391,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - w", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Fill",391,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"C - - 10 - name d - 'Double_t' 0 - w", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinContent",1300,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinContent",1300,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - bin i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinContent",1300,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - bin i - 'Int_t' 0 - - "
"i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinError",1091,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinError",1091,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - bin i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinError",1091,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - bin i - 'Int_t' 0 - - "
"i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Reset",515,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetKOrd",668,G__G__Hist_294_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - k", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Hist_294_0_16, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TH1K::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_294_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH1K::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_294_0_18, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TH1K::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_294_0_19, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TH1K::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_294_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_294_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH1K::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_294_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TH1K::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_294_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH1K::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_294_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TH1K::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TH1K", 280, G__G__Hist_294_0_28, (int) ('i'), G__get_linked_tagnum(&G__G__HistLN_TH1K), -1, 0, 1, 1, 1, 0, "u 'TH1K' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TH1K", 406, G__G__Hist_294_0_29, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTProfile(void) {
   /* TProfile */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TProfile));
   G__memfunc_setup("BufferFill",993,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 2, 0, 
"d - 'Double_t' 0 - - d - 'Double_t' 0 - -", "may not use", (void*) NULL, 1);
   G__memfunc_setup("BufferFill",993,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 2, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"d - 'Double_t' 0 - w", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBins",696,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"I - 'Int_t' 10 - nbins D - 'Double_t' 10 - range", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Fill",391,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 0, "D - 'Double_t' 10 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Fill",391,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 4, 0, "d - 'Double_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillN",469,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 4, 0, 
"i - 'Int_t' 0 - - D - 'Double_t' 10 - - "
"D - 'Double_t' 10 - - i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetB",354,(G__InterfaceMethod) NULL, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetB2",404,(G__InterfaceMethod) NULL, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetW",375,(G__InterfaceMethod) NULL, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetW2",425,(G__InterfaceMethod) NULL, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBins",696,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 6, 1, 4, 0, 
"i - 'Int_t' 0 - - d - 'Double_t' 0 - - "
"d - 'Double_t' 0 - - i - 'Int_t' 0 - - "
"d - 'Double_t' 0 - - d - 'Double_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBins",696,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 4, 0, 
"i - 'Int_t' 0 - - D - 'Double_t' 10 - - "
"i - 'Int_t' 0 - - D - 'Double_t' 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBins",696,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 9, 1, 4, 0, 
"i - 'Int_t' 0 - - d - 'Double_t' 0 - - "
"d - 'Double_t' 0 - - i - 'Int_t' 0 - - "
"d - 'Double_t' 0 - - d - 'Double_t' 0 - - "
"i - 'Int_t' 0 - - d - 'Double_t' 0 - - "
"d - 'Double_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBins",696,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 6, 1, 4, 0, 
"i - 'Int_t' 0 - - D - 'Double_t' 10 - - "
"i - 'Int_t' 0 - - D - 'Double_t' 10 - - "
"i - 'Int_t' 0 - - D - 'Double_t' 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TProfile",805,G__G__Hist_295_0_15, 105, G__get_linked_tagnum(&G__G__HistLN_TProfile), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TProfile",805,G__G__Hist_295_0_16, 105, G__get_linked_tagnum(&G__G__HistLN_TProfile), -1, 0, 6, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx d - 'Double_t' 0 - xlow "
"d - 'Double_t' 0 - xup C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TProfile",805,G__G__Hist_295_0_17, 105, G__get_linked_tagnum(&G__G__HistLN_TProfile), -1, 0, 8, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx d - 'Double_t' 0 - xlow "
"d - 'Double_t' 0 - xup d - 'Double_t' 0 - ylow "
"d - 'Double_t' 0 - yup C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TProfile",805,G__G__Hist_295_0_18, 105, G__get_linked_tagnum(&G__G__HistLN_TProfile), -1, 0, 5, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx F - 'Float_t' 10 - xbins "
"C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TProfile",805,G__G__Hist_295_0_19, 105, G__get_linked_tagnum(&G__G__HistLN_TProfile), -1, 0, 5, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx D - 'Double_t' 10 - xbins "
"C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TProfile",805,G__G__Hist_295_0_20, 105, G__get_linked_tagnum(&G__G__HistLN_TProfile), -1, 0, 7, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx D - 'Double_t' 10 - xbins "
"d - 'Double_t' 0 - ylow d - 'Double_t' 0 - yup "
"C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TProfile",805,G__G__Hist_295_0_21, 105, G__get_linked_tagnum(&G__G__HistLN_TProfile), -1, 0, 1, 1, 1, 0, "u 'TProfile' - 11 - profile", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Add",265,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TF1' - 0 - h1 d - 'Double_t' 0 '1' c1 "
"C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Add",265,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TH1' - 10 - h1 d - 'Double_t' 0 '1' c1", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Add",265,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 0, 
"U 'TH1' - 10 - h1 U 'TH1' - 10 - h2 "
"d - 'Double_t' 0 '1' c1 d - 'Double_t' 0 '1' c2", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Approximate",1162,G__G__Hist_295_0_25, 121, -1, -1, 0, 1, 3, 1, 0, "g - 'Bool_t' 0 'kTRUE' approx", (char*)NULL, (void*) G__func2void( (void (*)(Bool_t))(&TProfile::Approximate) ), 0);
   G__memfunc_setup("BufferEmpty",1129,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 '0' action", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("BuildOptions",1244,G__G__Hist_295_0_27, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - ymin d - 'Double_t' 0 - ymax "
"C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TObject' - 1 - hnew", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Divide",597,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TF1' - 0 - h1 d - 'Double_t' 0 '1' c1", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Divide",597,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TH1' - 10 - h1", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Divide",597,(G__InterfaceMethod) NULL,121, -1, -1, 0, 5, 1, 1, 0, 
"U 'TH1' - 10 - h1 U 'TH1' - 10 - h2 "
"d - 'Double_t' 0 '1' c1 d - 'Double_t' 0 '1' c2 "
"C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("DrawCopy",809,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TH1), -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Fill",391,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Fill",391,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"C - - 10 - namex d - 'Double_t' 0 - y", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Fill",391,G__G__Hist_295_0_35, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"d - 'Double_t' 0 - w", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Fill",391,G__G__Hist_295_0_36, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"C - - 10 - namex d - 'Double_t' 0 - y "
"d - 'Double_t' 0 - w", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillN",469,G__G__Hist_295_0_37, 121, -1, -1, 0, 5, 1, 1, 0, 
"i - 'Int_t' 0 - ntimes D - 'Double_t' 10 - x "
"D - 'Double_t' 10 - y D - 'Double_t' 10 - w "
"i - 'Int_t' 0 '1' stride", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinContent",1300,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinContent",1300,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - bin i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinContent",1300,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - bin i - 'Int_t' 0 - - "
"i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinError",1091,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinError",1091,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - bin i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinError",1091,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - bin i - 'Int_t' 0 - - "
"i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinEntries",1299,G__G__Hist_295_0_44, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinEffectiveEntries",2212,G__G__Hist_295_0_45, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinSumw2",1047,G__G__Hist_295_0_46, 85, G__get_linked_tagnum(&G__G__HistLN_TArrayD), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinSumw2",1047,G__G__Hist_295_0_47, 85, G__get_linked_tagnum(&G__G__HistLN_TArrayD), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetErrorOption",1443,G__G__Hist_295_0_48, 67, -1, G__defined_typename("Option_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetObjectInfo",1283,(G__InterfaceMethod) NULL,67, -1, -1, 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetStats",815,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - stats", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetYmin",701,G__G__Hist_295_0_51, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetYmax",703,G__G__Hist_295_0_52, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LabelsDeflate",1288,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"X\"' axis", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LabelsInflate",1302,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"X\"' axis", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LabelsOption",1228,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"C - 'Option_t' 10 '\"h\"' option C - 'Option_t' 10 '\"X\"' axis", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Merge",496,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 1, 1, 1, 0, "U 'TCollection' - 0 - list", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Multiply",864,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TF1' - 0 - h1 d - 'Double_t' 0 '1' c1", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Multiply",864,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TH1' - 10 - h1", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Multiply",864,(G__InterfaceMethod) NULL,121, -1, -1, 0, 5, 1, 1, 0, 
"U 'TH1' - 10 - h1 U 'TH1' - 10 - h2 "
"d - 'Double_t' 0 '1' c1 d - 'Double_t' 0 '1' c2 "
"C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("ProjectionX",1141,G__G__Hist_295_0_60, 85, G__get_linked_tagnum(&G__G__HistLN_TH1D), -1, 0, 2, 1, 1, 8, 
"C - - 10 '\"_px\"' name C - 'Option_t' 10 '\"e\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PutStats",840,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - stats", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Rebin",496,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TH1), -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 '2' ngroup C - - 10 '\"\"' newname "
"D - 'Double_t' 10 '0' xbins", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RebinAxis",901,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - x U 'TAxis' - 0 - axis", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Reset",515,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Scale",488,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 '1' c1 C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinEntries",1311,G__G__Hist_295_0_67, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - bin d - 'Double_t' 0 - w", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBins",696,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - nbins d - 'Double_t' 0 - xmin "
"d - 'Double_t' 0 - xmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBins",696,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - nx D - 'Double_t' 10 - xbins", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBuffer",902,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - buffersize C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetErrorOption",1455,G__G__Hist_295_0_71, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Sumw2",478,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Hist_295_0_73, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TProfile::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_295_0_74, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProfile::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_295_0_75, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TProfile::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_295_0_76, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TProfile::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_295_0_80, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_295_0_81, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProfile::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_295_0_82, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProfile::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_295_0_83, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProfile::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_295_0_84, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProfile::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TProfile", 931, G__G__Hist_295_0_85, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTH2C(void) {
   /* TH2C */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TH2C));
   G__memfunc_setup("TH2C",273,G__G__Hist_296_0_1, 105, G__get_linked_tagnum(&G__G__HistLN_TH2C), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH2C",273,G__G__Hist_296_0_2, 105, G__get_linked_tagnum(&G__G__HistLN_TH2C), -1, 0, 8, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx d - 'Double_t' 0 - xlow "
"d - 'Double_t' 0 - xup i - 'Int_t' 0 - nbinsy "
"d - 'Double_t' 0 - ylow d - 'Double_t' 0 - yup", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH2C",273,G__G__Hist_296_0_3, 105, G__get_linked_tagnum(&G__G__HistLN_TH2C), -1, 0, 7, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx D - 'Double_t' 10 - xbins "
"i - 'Int_t' 0 - nbinsy d - 'Double_t' 0 - ylow "
"d - 'Double_t' 0 - yup", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH2C",273,G__G__Hist_296_0_4, 105, G__get_linked_tagnum(&G__G__HistLN_TH2C), -1, 0, 7, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx d - 'Double_t' 0 - xlow "
"d - 'Double_t' 0 - xup i - 'Int_t' 0 - nbinsy "
"D - 'Double_t' 10 - ybins", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH2C",273,G__G__Hist_296_0_5, 105, G__get_linked_tagnum(&G__G__HistLN_TH2C), -1, 0, 6, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx D - 'Double_t' 10 - xbins "
"i - 'Int_t' 0 - nbinsy D - 'Double_t' 10 - ybins", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH2C",273,G__G__Hist_296_0_6, 105, G__get_linked_tagnum(&G__G__HistLN_TH2C), -1, 0, 6, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx F - 'Float_t' 10 - xbins "
"i - 'Int_t' 0 - nbinsy F - 'Float_t' 10 - ybins", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH2C",273,G__G__Hist_296_0_7, 105, G__get_linked_tagnum(&G__G__HistLN_TH2C), -1, 0, 1, 1, 1, 0, "u 'TH2C' - 11 - h2c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddBinContent",1277,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddBinContent",1277,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - bin d - 'Double_t' 0 - w", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TObject' - 1 - hnew", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawCopy",809,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TH1), -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinContent",1300,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinContent",1300,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - binx i - 'Int_t' 0 - biny", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinContent",1300,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - binx i - 'Int_t' 0 - biny "
"i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Reset",515,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinContent",1312,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - bin d - 'Double_t' 0 - content", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinContent",1312,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - binx i - 'Int_t' 0 - biny "
"d - 'Double_t' 0 - content", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinContent",1312,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - binx i - 'Int_t' 0 - biny "
"i - 'Int_t' 0 - - d - 'Double_t' 0 - content", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinsLength",1306,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '-1' n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator=",937,G__G__Hist_296_0_20, 117, G__get_linked_tagnum(&G__G__HistLN_TH2C), -1, 1, 1, 1, 1, 0, "u 'TH2C' - 11 - h1", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Hist_296_0_21, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TH2C::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_296_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH2C::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_296_0_23, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TH2C::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_296_0_24, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TH2C::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_296_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_296_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH2C::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_296_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TH2C::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_296_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH2C::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_296_0_32, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TH2C::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TH2C", 399, G__G__Hist_296_0_33, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTH2S(void) {
   /* TH2S */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TH2S));
   G__memfunc_setup("TH2S",289,G__G__Hist_297_0_1, 105, G__get_linked_tagnum(&G__G__HistLN_TH2S), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH2S",289,G__G__Hist_297_0_2, 105, G__get_linked_tagnum(&G__G__HistLN_TH2S), -1, 0, 8, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx d - 'Double_t' 0 - xlow "
"d - 'Double_t' 0 - xup i - 'Int_t' 0 - nbinsy "
"d - 'Double_t' 0 - ylow d - 'Double_t' 0 - yup", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH2S",289,G__G__Hist_297_0_3, 105, G__get_linked_tagnum(&G__G__HistLN_TH2S), -1, 0, 7, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx D - 'Double_t' 10 - xbins "
"i - 'Int_t' 0 - nbinsy d - 'Double_t' 0 - ylow "
"d - 'Double_t' 0 - yup", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH2S",289,G__G__Hist_297_0_4, 105, G__get_linked_tagnum(&G__G__HistLN_TH2S), -1, 0, 7, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx d - 'Double_t' 0 - xlow "
"d - 'Double_t' 0 - xup i - 'Int_t' 0 - nbinsy "
"D - 'Double_t' 10 - ybins", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH2S",289,G__G__Hist_297_0_5, 105, G__get_linked_tagnum(&G__G__HistLN_TH2S), -1, 0, 6, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx D - 'Double_t' 10 - xbins "
"i - 'Int_t' 0 - nbinsy D - 'Double_t' 10 - ybins", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH2S",289,G__G__Hist_297_0_6, 105, G__get_linked_tagnum(&G__G__HistLN_TH2S), -1, 0, 6, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx F - 'Float_t' 10 - xbins "
"i - 'Int_t' 0 - nbinsy F - 'Float_t' 10 - ybins", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH2S",289,G__G__Hist_297_0_7, 105, G__get_linked_tagnum(&G__G__HistLN_TH2S), -1, 0, 1, 1, 1, 0, "u 'TH2S' - 11 - h2s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddBinContent",1277,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddBinContent",1277,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - bin d - 'Double_t' 0 - w", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TObject' - 1 - hnew", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawCopy",809,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TH1), -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinContent",1300,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinContent",1300,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - binx i - 'Int_t' 0 - biny", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinContent",1300,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - binx i - 'Int_t' 0 - biny "
"i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Reset",515,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinContent",1312,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - bin d - 'Double_t' 0 - content", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinContent",1312,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - binx i - 'Int_t' 0 - biny "
"d - 'Double_t' 0 - content", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinContent",1312,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - binx i - 'Int_t' 0 - biny "
"i - 'Int_t' 0 - - d - 'Double_t' 0 - content", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinsLength",1306,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '-1' n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator=",937,G__G__Hist_297_0_20, 117, G__get_linked_tagnum(&G__G__HistLN_TH2S), -1, 1, 1, 1, 1, 0, "u 'TH2S' - 11 - h1", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Hist_297_0_21, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TH2S::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_297_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH2S::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_297_0_23, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TH2S::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_297_0_24, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TH2S::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_297_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_297_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH2S::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_297_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TH2S::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_297_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH2S::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_297_0_32, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TH2S::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TH2S", 415, G__G__Hist_297_0_33, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTH2I(void) {
   /* TH2I */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TH2I));
   G__memfunc_setup("TH2I",279,G__G__Hist_298_0_1, 105, G__get_linked_tagnum(&G__G__HistLN_TH2I), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH2I",279,G__G__Hist_298_0_2, 105, G__get_linked_tagnum(&G__G__HistLN_TH2I), -1, 0, 8, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx d - 'Double_t' 0 - xlow "
"d - 'Double_t' 0 - xup i - 'Int_t' 0 - nbinsy "
"d - 'Double_t' 0 - ylow d - 'Double_t' 0 - yup", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH2I",279,G__G__Hist_298_0_3, 105, G__get_linked_tagnum(&G__G__HistLN_TH2I), -1, 0, 7, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx D - 'Double_t' 10 - xbins "
"i - 'Int_t' 0 - nbinsy d - 'Double_t' 0 - ylow "
"d - 'Double_t' 0 - yup", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH2I",279,G__G__Hist_298_0_4, 105, G__get_linked_tagnum(&G__G__HistLN_TH2I), -1, 0, 7, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx d - 'Double_t' 0 - xlow "
"d - 'Double_t' 0 - xup i - 'Int_t' 0 - nbinsy "
"D - 'Double_t' 10 - ybins", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH2I",279,G__G__Hist_298_0_5, 105, G__get_linked_tagnum(&G__G__HistLN_TH2I), -1, 0, 6, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx D - 'Double_t' 10 - xbins "
"i - 'Int_t' 0 - nbinsy D - 'Double_t' 10 - ybins", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH2I",279,G__G__Hist_298_0_6, 105, G__get_linked_tagnum(&G__G__HistLN_TH2I), -1, 0, 6, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx F - 'Float_t' 10 - xbins "
"i - 'Int_t' 0 - nbinsy F - 'Float_t' 10 - ybins", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH2I",279,G__G__Hist_298_0_7, 105, G__get_linked_tagnum(&G__G__HistLN_TH2I), -1, 0, 1, 1, 1, 0, "u 'TH2I' - 11 - h2i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddBinContent",1277,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddBinContent",1277,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - bin d - 'Double_t' 0 - w", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TObject' - 1 - hnew", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawCopy",809,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TH1), -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinContent",1300,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinContent",1300,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - binx i - 'Int_t' 0 - biny", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinContent",1300,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - binx i - 'Int_t' 0 - biny "
"i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Reset",515,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinContent",1312,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - bin d - 'Double_t' 0 - content", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinContent",1312,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - binx i - 'Int_t' 0 - biny "
"d - 'Double_t' 0 - content", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinContent",1312,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - binx i - 'Int_t' 0 - biny "
"i - 'Int_t' 0 - - d - 'Double_t' 0 - content", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinsLength",1306,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '-1' n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator=",937,G__G__Hist_298_0_20, 117, G__get_linked_tagnum(&G__G__HistLN_TH2I), -1, 1, 1, 1, 1, 0, "u 'TH2I' - 11 - h1", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Hist_298_0_21, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TH2I::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_298_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH2I::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_298_0_23, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TH2I::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_298_0_24, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TH2I::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_298_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_298_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH2I::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_298_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TH2I::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_298_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH2I::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_298_0_32, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TH2I::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TH2I", 405, G__G__Hist_298_0_33, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTH2F(void) {
   /* TH2F */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TH2F));
   G__memfunc_setup("TH2F",276,G__G__Hist_299_0_1, 105, G__get_linked_tagnum(&G__G__HistLN_TH2F), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH2F",276,G__G__Hist_299_0_2, 105, G__get_linked_tagnum(&G__G__HistLN_TH2F), -1, 0, 8, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx d - 'Double_t' 0 - xlow "
"d - 'Double_t' 0 - xup i - 'Int_t' 0 - nbinsy "
"d - 'Double_t' 0 - ylow d - 'Double_t' 0 - yup", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH2F",276,G__G__Hist_299_0_3, 105, G__get_linked_tagnum(&G__G__HistLN_TH2F), -1, 0, 7, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx D - 'Double_t' 10 - xbins "
"i - 'Int_t' 0 - nbinsy d - 'Double_t' 0 - ylow "
"d - 'Double_t' 0 - yup", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH2F",276,G__G__Hist_299_0_4, 105, G__get_linked_tagnum(&G__G__HistLN_TH2F), -1, 0, 7, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx d - 'Double_t' 0 - xlow "
"d - 'Double_t' 0 - xup i - 'Int_t' 0 - nbinsy "
"D - 'Double_t' 10 - ybins", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH2F",276,G__G__Hist_299_0_5, 105, G__get_linked_tagnum(&G__G__HistLN_TH2F), -1, 0, 6, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx D - 'Double_t' 10 - xbins "
"i - 'Int_t' 0 - nbinsy D - 'Double_t' 10 - ybins", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH2F",276,G__G__Hist_299_0_6, 105, G__get_linked_tagnum(&G__G__HistLN_TH2F), -1, 0, 6, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx F - 'Float_t' 10 - xbins "
"i - 'Int_t' 0 - nbinsy F - 'Float_t' 10 - ybins", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH2F",276,G__G__Hist_299_0_7, 105, G__get_linked_tagnum(&G__G__HistLN_TH2F), -1, 0, 1, 1, 1, 0, "u 'TMatrixTBase<float>' 'TMatrixFBase' 11 - m", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH2F",276,G__G__Hist_299_0_8, 105, G__get_linked_tagnum(&G__G__HistLN_TH2F), -1, 0, 1, 1, 1, 0, "u 'TH2F' - 11 - h2f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddBinContent",1277,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddBinContent",1277,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - bin d - 'Double_t' 0 - w", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TObject' - 1 - hnew", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawCopy",809,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TH1), -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinContent",1300,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinContent",1300,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - binx i - 'Int_t' 0 - biny", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinContent",1300,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - binx i - 'Int_t' 0 - biny "
"i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Reset",515,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinContent",1312,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - bin d - 'Double_t' 0 - content", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinContent",1312,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - binx i - 'Int_t' 0 - biny "
"d - 'Double_t' 0 - content", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinContent",1312,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - binx i - 'Int_t' 0 - biny "
"i - 'Int_t' 0 - - d - 'Double_t' 0 - content", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinsLength",1306,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '-1' n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator=",937,G__G__Hist_299_0_21, 117, G__get_linked_tagnum(&G__G__HistLN_TH2F), -1, 1, 1, 1, 1, 0, "u 'TH2F' - 11 - h1", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Hist_299_0_22, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TH2F::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_299_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH2F::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_299_0_24, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TH2F::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_299_0_25, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TH2F::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_299_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_299_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH2F::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_299_0_31, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TH2F::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_299_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH2F::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_299_0_33, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TH2F::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TH2F", 402, G__G__Hist_299_0_34, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTH2PolyBin(void) {
   /* TH2PolyBin */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TH2PolyBin));
   G__memfunc_setup("TH2PolyBin",907,G__G__Hist_303_0_1, 105, G__get_linked_tagnum(&G__G__HistLN_TH2PolyBin), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH2PolyBin",907,G__G__Hist_303_0_2, 105, G__get_linked_tagnum(&G__G__HistLN_TH2PolyBin), -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - poly i - 'Int_t' 0 - bin_number", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ClearContent",1218,G__G__Hist_303_0_3, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Fill",391,G__G__Hist_303_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - w", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetArea",665,G__G__Hist_303_0_5, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetContent",1019,G__G__Hist_303_0_6, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetChanged",970,G__G__Hist_303_0_7, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBinNumber",1186,G__G__Hist_303_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPolygon",1032,G__G__Hist_303_0_9, 85, G__get_linked_tagnum(&G__G__HistLN_TObject), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetXMax",670,G__G__Hist_303_0_10, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetXMin",668,G__G__Hist_303_0_11, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetYMax",671,G__G__Hist_303_0_12, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetYMin",669,G__G__Hist_303_0_13, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsInside",792,G__G__Hist_303_0_14, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 8, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetChanged",982,G__G__Hist_303_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetContent",1031,G__G__Hist_303_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - content", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Hist_303_0_17, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TH2PolyBin::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_303_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH2PolyBin::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_303_0_19, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TH2PolyBin::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_303_0_20, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TH2PolyBin::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_303_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_303_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH2PolyBin::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_303_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TH2PolyBin::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_303_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH2PolyBin::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_303_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TH2PolyBin::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TH2PolyBin", 907, G__G__Hist_303_0_29, (int) ('i'), G__get_linked_tagnum(&G__G__HistLN_TH2PolyBin), -1, 0, 1, 1, 1, 0, "u 'TH2PolyBin' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TH2PolyBin", 1033, G__G__Hist_303_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__G__Hist_303_0_31, (int) ('u'), G__get_linked_tagnum(&G__G__HistLN_TH2PolyBin), -1, 1, 1, 1, 1, 0, "u 'TH2PolyBin' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTH2Poly(void) {
   /* TH2Poly */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TH2Poly));
   G__memfunc_setup("TH2Poly",626,G__G__Hist_305_0_1, 105, G__get_linked_tagnum(&G__G__HistLN_TH2Poly), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH2Poly",626,G__G__Hist_305_0_2, 105, G__get_linked_tagnum(&G__G__HistLN_TH2Poly), -1, 0, 6, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"d - 'Double_t' 0 - xlow d - 'Double_t' 0 - xup "
"d - 'Double_t' 0 - ylow d - 'Double_t' 0 - yup", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH2Poly",626,G__G__Hist_305_0_3, 105, G__get_linked_tagnum(&G__G__HistLN_TH2Poly), -1, 0, 8, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nX d - 'Double_t' 0 - xlow "
"d - 'Double_t' 0 - xup i - 'Int_t' 0 - nY "
"d - 'Double_t' 0 - ylow d - 'Double_t' 0 - yup", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddBin",546,G__G__Hist_305_0_4, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TObject' - 0 - poly", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddBin",546,G__G__Hist_305_0_5, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - n D - 'Double_t' 10 - x "
"D - 'Double_t' 10 - y", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddBin",546,G__G__Hist_305_0_6, 105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - x1 d - 'Double_t' 0 - y1 "
"d - 'Double_t' 0 - x2 d - 'Double_t' 0 - y2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ClearBinContents",1614,G__G__Hist_305_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", "Clears the content of all bins", (void*) NULL, 0);
   G__memfunc_setup("ChangePartition",1536,G__G__Hist_305_0_8, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - n i - 'Int_t' 0 - m", "Sets the number of partition cells to another value", (void*) NULL, 0);
   G__memfunc_setup("DrawCopy",809,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TH1), -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Fill",391,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Fill",391,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"d - 'Double_t' 0 - w", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Fill",391,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"C - - 10 - name d - 'Double_t' 0 - w", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillN",469,(G__InterfaceMethod) NULL,121, -1, -1, 0, 5, 1, 1, 0, 
"i - 'Int_t' 0 - ntimes D - 'Double_t' 10 - x "
"D - 'Double_t' 10 - y D - 'Double_t' 10 - w "
"i - 'Int_t' 0 '1' stride", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Fill",391,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - -", "MayNotUse", (void*) NULL, 1);
   G__memfunc_setup("Fill",391,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - - C - - 10 - - "
"d - 'Double_t' 0 - -", "MayNotUse", (void*) NULL, 1);
   G__memfunc_setup("Fill",391,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"C - - 10 - - d - 'Double_t' 0 - - "
"d - 'Double_t' 0 - -", "MayNotUse", (void*) NULL, 1);
   G__memfunc_setup("Fill",391,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"C - - 10 - - C - - 10 - - "
"d - 'Double_t' 0 - -", "MayNotUse", (void*) NULL, 1);
   G__memfunc_setup("FillN",469,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - - D - 'Double_t' 10 - - "
"D - 'Double_t' 10 - - i - 'Int_t' 0 - -", "MayNotUse", (void*) NULL, 1);
   G__memfunc_setup("FindBin",666,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"d - 'Double_t' 0 '0' z", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBins",684,G__G__Hist_305_0_20, 85, G__get_linked_tagnum(&G__G__HistLN_TList), -1, 0, 0, 1, 1, 0, "", "Returns the TList of all bins in the histogram", (void*) NULL, 0);
   G__memfunc_setup("GetBinContent",1300,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinContent",1300,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - - i - 'Int_t' 0 - -", "MayNotUse", (void*) NULL, 1);
   G__memfunc_setup("GetBinContent",1300,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - - i - 'Int_t' 0 - - "
"i - 'Int_t' 0 - -", "MayNotUse", (void*) NULL, 1);
   G__memfunc_setup("GetBinContentChanged",1982,G__G__Hist_305_0_24, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBinError",1091,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinError",1091,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - - i - 'Int_t' 0 - -", "MayNotUse", (void*) NULL, 1);
   G__memfunc_setup("GetBinError",1091,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - - i - 'Int_t' 0 - - "
"i - 'Int_t' 0 - -", "MayNotUse", (void*) NULL, 1);
   G__memfunc_setup("GetBinName",954,G__G__Hist_305_0_28, 67, -1, -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBinTitle",1083,G__G__Hist_305_0_29, 67, -1, -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFloat",790,G__G__Hist_305_0_30, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMaximum",1022,G__G__Hist_305_0_31, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMaximum",1022,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "d - 'Double_t' 0 - maxval", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMinimum",1020,G__G__Hist_305_0_33, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMinimum",1020,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "d - 'Double_t' 0 - minval", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNewBinAdded",1333,G__G__Hist_305_0_35, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNumberOfBins",1482,G__G__Hist_305_0_36, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Honeycomb",932,G__G__Hist_305_0_37, 121, -1, -1, 0, 5, 1, 1, 0, 
"d - 'Double_t' 0 - xstart d - 'Double_t' 0 - ystart "
"d - 'Double_t' 0 - a i - 'Int_t' 0 - k "
"i - 'Int_t' 0 - s", "Bins the histogram using a honeycomb structure", (void*) NULL, 0);
   G__memfunc_setup("Integral",822,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Integral",822,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - - i - 'Int_t' 0 - - "
"C - 'Option_t' 10 - -", "MayNotUse", (void*) NULL, 1);
   G__memfunc_setup("Integral",822,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"i - 'Int_t' 0 - - i - 'Int_t' 0 - - "
"i - 'Int_t' 0 - - i - 'Int_t' 0 - - "
"C - 'Option_t' 10 - -", "MayNotUse", (void*) NULL, 1);
   G__memfunc_setup("Integral",822,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 7, 1, 1, 8, 
"i - 'Int_t' 0 - - i - 'Int_t' 0 - - "
"i - 'Int_t' 0 - - i - 'Int_t' 0 - - "
"i - 'Int_t' 0 - - i - 'Int_t' 0 - - "
"C - 'Option_t' 10 - -", "MayNotUse", (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinContent",1312,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - bin d - 'Double_t' 0 - content", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinContent",1312,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - - i - 'Int_t' 0 - - "
"d - 'Double_t' 0 - -", "MayNotUse", (void*) NULL, 1);
   G__memfunc_setup("SetBinContent",1312,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - - i - 'Int_t' 0 - - "
"i - 'Int_t' 0 - - d - 'Double_t' 0 - -", "MayNotUse", (void*) NULL, 1);
   G__memfunc_setup("SetBinContentChanged",1994,G__G__Hist_305_0_46, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFloat",802,G__G__Hist_305_0_47, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'true' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNewBinAdded",1345,G__G__Hist_305_0_48, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddBinToPartition",1695,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TH2PolyBin' - 0 - bin", "Adds the input bin into the partition matrix", (void*) NULL, 0);
   G__memfunc_setup("Initialize",1042,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 6, 1, 2, 0, 
"d - 'Double_t' 0 - xlow d - 'Double_t' 0 - xup "
"d - 'Double_t' 0 - ylow d - 'Double_t' 0 - yup "
"i - 'Int_t' 0 - n i - 'Int_t' 0 - m", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsIntersecting",1451,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 5, 1, 2, 0, 
"U 'TH2PolyBin' - 0 - bin d - 'Double_t' 0 - xclipl "
"d - 'Double_t' 0 - xclipr d - 'Double_t' 0 - yclipb "
"d - 'Double_t' 0 - yclipt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsIntersectingPolygon",2195,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 7, 1, 2, 0, 
"i - 'Int_t' 0 - bn D - 'Double_t' 0 - x "
"D - 'Double_t' 0 - y d - 'Double_t' 0 - xclipl "
"d - 'Double_t' 0 - xclipr d - 'Double_t' 0 - yclipb "
"d - 'Double_t' 0 - yclipt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Hist_305_0_53, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TH2Poly::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_305_0_54, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH2Poly::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_305_0_55, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TH2Poly::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_305_0_56, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TH2Poly::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_305_0_60, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_305_0_61, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH2Poly::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_305_0_62, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TH2Poly::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_305_0_63, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH2Poly::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_305_0_64, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TH2Poly::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TH2Poly", 626, G__G__Hist_305_0_65, (int) ('i'), G__get_linked_tagnum(&G__G__HistLN_TH2Poly), -1, 0, 1, 1, 1, 0, "u 'TH2Poly' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TH2Poly", 752, G__G__Hist_305_0_66, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTProfile2D(void) {
   /* TProfile2D */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TProfile2D));
   G__memfunc_setup("BufferFill",993,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 2, 0, 
"d - 'Double_t' 0 - - d - 'Double_t' 0 - -", "may not use", (void*) NULL, 1);
   G__memfunc_setup("BufferFill",993,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 2, 0, 
"d - 'Double_t' 0 - - d - 'Double_t' 0 - - "
"d - 'Double_t' 0 - -", "may not use", (void*) NULL, 1);
   G__memfunc_setup("BufferFill",993,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 4, 1, 2, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"d - 'Double_t' 0 - z d - 'Double_t' 0 - w", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBins",696,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"I - 'Int_t' 10 - nbins D - 'Double_t' 10 - range", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Fill",391,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 0, "D - 'Double_t' 10 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetB",354,(G__InterfaceMethod) NULL, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetB2",404,(G__InterfaceMethod) NULL, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetW",375,(G__InterfaceMethod) NULL, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetW2",425,(G__InterfaceMethod) NULL, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBins",696,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 4, 0, 
"i - 'Int_t' 0 - - d - 'Double_t' 0 - - "
"d - 'Double_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBins",696,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
"i - 'Int_t' 0 - - D - 'Double_t' 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBins",696,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 4, 0, 
"i - 'Int_t' 0 - - D - 'Double_t' 10 - - "
"i - 'Int_t' 0 - - D - 'Double_t' 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBins",696,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 9, 1, 4, 0, 
"i - 'Int_t' 0 - - d - 'Double_t' 0 - - "
"d - 'Double_t' 0 - - i - 'Int_t' 0 - - "
"d - 'Double_t' 0 - - d - 'Double_t' 0 - - "
"i - 'Int_t' 0 - - d - 'Double_t' 0 - - "
"d - 'Double_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBins",696,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 6, 1, 4, 0, 
"i - 'Int_t' 0 - - D - 'Double_t' 10 - - "
"i - 'Int_t' 0 - - D - 'Double_t' 10 - - "
"i - 'Int_t' 0 - - D - 'Double_t' 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TProfile2D",923,G__G__Hist_307_0_15, 105, G__get_linked_tagnum(&G__G__HistLN_TProfile2D), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TProfile2D",923,G__G__Hist_307_0_16, 105, G__get_linked_tagnum(&G__G__HistLN_TProfile2D), -1, 0, 11, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx d - 'Double_t' 0 - xlow "
"d - 'Double_t' 0 - xup i - 'Int_t' 0 - nbinsy "
"d - 'Double_t' 0 - ylow d - 'Double_t' 0 - yup "
"d - 'Double_t' 0 - zlow d - 'Double_t' 0 - zup "
"C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TProfile2D",923,G__G__Hist_307_0_17, 105, G__get_linked_tagnum(&G__G__HistLN_TProfile2D), -1, 0, 9, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx d - 'Double_t' 0 - xlow "
"d - 'Double_t' 0 - xup i - 'Int_t' 0 - nbinsy "
"d - 'Double_t' 0 - ylow d - 'Double_t' 0 - yup "
"C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TProfile2D",923,G__G__Hist_307_0_18, 105, G__get_linked_tagnum(&G__G__HistLN_TProfile2D), -1, 0, 8, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx D - 'Double_t' 10 - xbins "
"i - 'Int_t' 0 - nbinsy d - 'Double_t' 0 - ylow "
"d - 'Double_t' 0 - yup C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TProfile2D",923,G__G__Hist_307_0_19, 105, G__get_linked_tagnum(&G__G__HistLN_TProfile2D), -1, 0, 8, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx d - 'Double_t' 0 - xlow "
"d - 'Double_t' 0 - xup i - 'Int_t' 0 - nbinsy "
"D - 'Double_t' 10 - ybins C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TProfile2D",923,G__G__Hist_307_0_20, 105, G__get_linked_tagnum(&G__G__HistLN_TProfile2D), -1, 0, 7, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx D - 'Double_t' 10 - xbins "
"i - 'Int_t' 0 - nbinsy D - 'Double_t' 10 - ybins "
"C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TProfile2D",923,G__G__Hist_307_0_21, 105, G__get_linked_tagnum(&G__G__HistLN_TProfile2D), -1, 0, 1, 1, 1, 0, "u 'TProfile2D' - 11 - profile", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Add",265,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TF1' - 0 - h1 d - 'Double_t' 0 '1' c1 "
"C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Add",265,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TH1' - 10 - h1 d - 'Double_t' 0 '1' c1", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Add",265,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 0, 
"U 'TH1' - 10 - h1 U 'TH1' - 10 - h2 "
"d - 'Double_t' 0 '1' c1 d - 'Double_t' 0 '1' c2", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Approximate",1162,G__G__Hist_307_0_25, 121, -1, -1, 0, 1, 3, 1, 0, "g - 'Bool_t' 0 'kTRUE' approx", (char*)NULL, (void*) G__func2void( (void (*)(Bool_t))(&TProfile2D::Approximate) ), 0);
   G__memfunc_setup("BuildOptions",1244,G__G__Hist_307_0_26, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - zmin d - 'Double_t' 0 - zmax "
"C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BufferEmpty",1129,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 '0' action", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TObject' - 1 - hnew", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Divide",597,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TF1' - 0 - h1 d - 'Double_t' 0 '1' c1", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Divide",597,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TH1' - 10 - h1", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Divide",597,(G__InterfaceMethod) NULL,121, -1, -1, 0, 5, 1, 1, 0, 
"U 'TH1' - 10 - h1 U 'TH1' - 10 - h2 "
"d - 'Double_t' 0 '1' c1 d - 'Double_t' 0 '1' c2 "
"C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("DrawCopy",809,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TH1), -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Fill",391,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - -", "MayNotUse", (void*) NULL, 1);
   G__memfunc_setup("Fill",391,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"C - - 10 - - d - 'Double_t' 0 - -", "MayNotUse", (void*) NULL, 1);
   G__memfunc_setup("Fill",391,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - - d - 'Double_t' 0 - -", "MayNotUse", (void*) NULL, 1);
   G__memfunc_setup("Fill",391,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Fill",391,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - x C - - 10 - namey "
"d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Fill",391,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"C - - 10 - namex d - 'Double_t' 0 - y "
"d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Fill",391,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"C - - 10 - namex C - - 10 - namey "
"d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Fill",391,G__G__Hist_307_0_40, 105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"d - 'Double_t' 0 - z d - 'Double_t' 0 - w", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinContent",1300,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinContent",1300,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - binx i - 'Int_t' 0 - biny", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinContent",1300,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - binx i - 'Int_t' 0 - biny "
"i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinError",1091,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinError",1091,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - binx i - 'Int_t' 0 - biny", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinError",1091,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - binx i - 'Int_t' 0 - biny "
"i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinEntries",1299,G__G__Hist_307_0_47, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinEffectiveEntries",2212,G__G__Hist_307_0_48, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinSumw2",1047,G__G__Hist_307_0_49, 85, G__get_linked_tagnum(&G__G__HistLN_TArrayD), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinSumw2",1047,G__G__Hist_307_0_50, 85, G__get_linked_tagnum(&G__G__HistLN_TArrayD), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetErrorOption",1443,G__G__Hist_307_0_51, 67, -1, G__defined_typename("Option_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStats",815,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - stats", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetZmin",702,G__G__Hist_307_0_53, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetZmax",704,G__G__Hist_307_0_54, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LabelsDeflate",1288,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"X\"' axis", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LabelsInflate",1302,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"X\"' axis", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LabelsOption",1228,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"C - 'Option_t' 10 '\"h\"' option C - 'Option_t' 10 '\"X\"' axis", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Merge",496,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 1, 1, 1, 0, "U 'TCollection' - 0 - list", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Multiply",864,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TF1' - 0 - h1 d - 'Double_t' 0 '1' c1", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Multiply",864,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TH1' - 10 - h1", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Multiply",864,(G__InterfaceMethod) NULL,121, -1, -1, 0, 5, 1, 1, 0, 
"U 'TH1' - 10 - h1 U 'TH1' - 10 - h2 "
"d - 'Double_t' 0 '1' c1 d - 'Double_t' 0 '1' c2 "
"C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("ProjectionXY",1230,G__G__Hist_307_0_62, 85, G__get_linked_tagnum(&G__G__HistLN_TH2D), -1, 0, 2, 1, 1, 8, 
"C - - 10 '\"_pxy\"' name C - 'Option_t' 10 '\"e\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PutStats",840,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - stats", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Reset",515,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RebinAxis",901,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - x U 'TAxis' - 0 - axis", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Rebin2D",614,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TProfile2D), -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 '2' nxgroup i - 'Int_t' 0 '2' nygroup "
"C - - 10 '\"\"' newname", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RebinX",584,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TProfile2D), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 '2' ngroup C - - 10 '\"\"' newname", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RebinY",585,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TProfile2D), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 '2' ngroup C - - 10 '\"\"' newname", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Scale",488,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 '1' c1 C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinEntries",1311,G__G__Hist_307_0_71, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - bin d - 'Double_t' 0 - w", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBins",696,(G__InterfaceMethod) NULL,121, -1, -1, 0, 6, 1, 1, 0, 
"i - 'Int_t' 0 - nbinsx d - 'Double_t' 0 - xmin "
"d - 'Double_t' 0 - xmax i - 'Int_t' 0 - nbinsy "
"d - 'Double_t' 0 - ymin d - 'Double_t' 0 - ymax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBuffer",902,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - buffersize C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetErrorOption",1455,G__G__Hist_307_0_74, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Sumw2",478,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Hist_307_0_76, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TProfile2D::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_307_0_77, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProfile2D::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_307_0_78, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TProfile2D::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_307_0_79, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TProfile2D::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_307_0_83, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_307_0_84, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProfile2D::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_307_0_85, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProfile2D::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_307_0_86, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProfile2D::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_307_0_87, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProfile2D::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TProfile2D", 1049, G__G__Hist_307_0_88, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTH3(void) {
   /* TH3 */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TH3));
   G__memfunc_setup("TH3",207,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__HistLN_TH3), -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH3",207,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__HistLN_TH3), -1, 0, 11, 1, 2, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx d - 'Double_t' 0 - xlow "
"d - 'Double_t' 0 - xup i - 'Int_t' 0 - nbinsy "
"d - 'Double_t' 0 - ylow d - 'Double_t' 0 - yup "
"i - 'Int_t' 0 - nbinsz d - 'Double_t' 0 - zlow "
"d - 'Double_t' 0 - zup", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH3",207,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__HistLN_TH3), -1, 0, 8, 1, 2, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx F - 'Float_t' 10 - xbins "
"i - 'Int_t' 0 - nbinsy F - 'Float_t' 10 - ybins "
"i - 'Int_t' 0 - nbinsz F - 'Float_t' 10 - zbins", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH3",207,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__HistLN_TH3), -1, 0, 8, 1, 2, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx D - 'Double_t' 10 - xbins "
"i - 'Int_t' 0 - nbinsy D - 'Double_t' 10 - ybins "
"i - 'Int_t' 0 - nbinsz D - 'Double_t' 10 - zbins", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BufferFill",993,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 2, 0, 
"d - 'Double_t' 0 - - d - 'Double_t' 0 - -", "may not use", (void*) NULL, 1);
   G__memfunc_setup("BufferFill",993,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 2, 0, 
"d - 'Double_t' 0 - - d - 'Double_t' 0 - - "
"d - 'Double_t' 0 - -", "may not use", (void*) NULL, 1);
   G__memfunc_setup("BufferFill",993,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 4, 1, 2, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"d - 'Double_t' 0 - z d - 'Double_t' 0 - w", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoFillProfileProjection",2344,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 9, 1, 2, 8, 
"U 'TProfile2D' - 0 - p2 u 'TAxis' - 11 - a1 "
"u 'TAxis' - 11 - a2 u 'TAxis' - 11 - a3 "
"i - 'Int_t' 0 - bin1 i - 'Int_t' 0 - bin2 "
"i - 'Int_t' 0 - bin3 i - 'Int_t' 0 - inBin "
"g - 'Bool_t' 0 - useWeights", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH3",207,G__G__Hist_308_0_9, 105, G__get_linked_tagnum(&G__G__HistLN_TH3), -1, 0, 1, 1, 1, 0, "u 'TH3' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BufferEmpty",1129,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 '0' action", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TObject' - 1 - hnew", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Fill",391,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - -", "MayNotUse", (void*) NULL, 1);
   G__memfunc_setup("Fill",391,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - - d - 'Double_t' 0 - -", "MayNotUse", (void*) NULL, 1);
   G__memfunc_setup("Fill",391,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"C - - 10 - - d - 'Double_t' 0 - -", "MayNotUse", (void*) NULL, 1);
   G__memfunc_setup("Fill",391,G__G__Hist_308_0_15, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - - C - - 10 - - "
"d - 'Double_t' 0 - -", "MayNotUse", (void*) NULL, 0);
   G__memfunc_setup("Fill",391,G__G__Hist_308_0_16, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"C - - 10 - - d - 'Double_t' 0 - - "
"d - 'Double_t' 0 - -", "MayNotUse", (void*) NULL, 0);
   G__memfunc_setup("Fill",391,G__G__Hist_308_0_17, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"C - - 10 - - C - - 10 - - "
"d - 'Double_t' 0 - -", "MayNotUse", (void*) NULL, 0);
   G__memfunc_setup("Fill",391,G__G__Hist_308_0_18, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Fill",391,G__G__Hist_308_0_19, 105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"d - 'Double_t' 0 - z d - 'Double_t' 0 - w", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Fill",391,G__G__Hist_308_0_20, 105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
"C - - 10 - namex C - - 10 - namey "
"C - - 10 - namez d - 'Double_t' 0 - w", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Fill",391,G__G__Hist_308_0_21, 105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
"C - - 10 - namex d - 'Double_t' 0 - y "
"C - - 10 - namez d - 'Double_t' 0 - w", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Fill",391,G__G__Hist_308_0_22, 105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
"C - - 10 - namex C - - 10 - namey "
"d - 'Double_t' 0 - z d - 'Double_t' 0 - w", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Fill",391,G__G__Hist_308_0_23, 105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - x C - - 10 - namey "
"C - - 10 - namez d - 'Double_t' 0 - w", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Fill",391,G__G__Hist_308_0_24, 105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - x C - - 10 - namey "
"d - 'Double_t' 0 - z d - 'Double_t' 0 - w", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Fill",391,G__G__Hist_308_0_25, 105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"C - - 10 - namez d - 'Double_t' 0 - w", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillRandom",1000,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - fname i - 'Int_t' 0 '5000' ntimes", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillRandom",1000,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TH1' - 0 - h i - 'Int_t' 0 '5000' ntimes", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindFirstBinAbove",1679,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 8, 
"d - 'Double_t' 0 '0' threshold i - 'Int_t' 0 '1' axis", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindLastBinAbove",1563,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 8, 
"d - 'Double_t' 0 '0' threshold i - 'Int_t' 0 '1' axis", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FitSlicesZ",992,G__G__Hist_308_0_30, 121, -1, -1, 0, 7, 1, 1, 0, 
"U 'TF1' - 0 '0' f1 i - 'Int_t' 0 '1' binminx "
"i - 'Int_t' 0 '0' binmaxx i - 'Int_t' 0 '1' binminy "
"i - 'Int_t' 0 '0' binmaxy i - 'Int_t' 0 '0' cut "
"C - 'Option_t' 10 '\"QNR\"' option", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("GetBinWithContent3",1763,G__G__Hist_308_0_31, 100, -1, G__defined_typename("Double_t"), 0, 11, 1, 1, 8, 
"d - 'Double_t' 0 - c i - 'Int_t' 1 - binx "
"i - 'Int_t' 1 - biny i - 'Int_t' 1 - binz "
"i - 'Int_t' 0 '0' firstx i - 'Int_t' 0 '0' lastx "
"i - 'Int_t' 0 '0' firsty i - 'Int_t' 0 '0' lasty "
"i - 'Int_t' 0 '0' firstz i - 'Int_t' 0 '0' lastz "
"d - 'Double_t' 0 '0' maxdiff", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCorrelationFactor",2049,G__G__Hist_308_0_32, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 '1' axis1 i - 'Int_t' 0 '2' axis2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCovariance",1307,G__G__Hist_308_0_33, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 '1' axis1 i - 'Int_t' 0 '2' axis2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRandom3",948,G__G__Hist_308_0_34, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 1 - x d - 'Double_t' 1 - y "
"d - 'Double_t' 1 - z", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetStats",815,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - stats", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Integral",822,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Integral",822,G__G__Hist_308_0_37, 100, -1, G__defined_typename("Double_t"), 0, 7, 1, 1, 8, 
"i - 'Int_t' 0 - binx1 i - 'Int_t' 0 - binx2 "
"i - 'Int_t' 0 - biny1 i - 'Int_t' 0 - biny2 "
"i - 'Int_t' 0 - binz1 i - 'Int_t' 0 - binz2 "
"C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IntegralAndError",1619,G__G__Hist_308_0_38, 100, -1, G__defined_typename("Double_t"), 0, 8, 1, 1, 8, 
"i - 'Int_t' 0 - binx1 i - 'Int_t' 0 - binx2 "
"i - 'Int_t' 0 - biny1 i - 'Int_t' 0 - biny2 "
"i - 'Int_t' 0 - binz1 i - 'Int_t' 0 - binz2 "
"d - 'Double_t' 1 - err C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Interpolate",1159,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Interpolate",1159,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Interpolate",1159,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("KolmogorovTest",1487,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"U 'TH1' - 10 - h2 C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Merge",496,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 1, 1, 1, 0, "U 'TCollection' - 0 - list", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProjectionX",1141,G__G__Hist_308_0_44, 85, G__get_linked_tagnum(&G__G__HistLN_TH1D), -1, 0, 6, 1, 1, 8, 
"C - - 10 '\"_px\"' name i - 'Int_t' 0 '0' firstybin "
"i - 'Int_t' 0 '-1' lastybin i - 'Int_t' 0 '0' firstzbin "
"i - 'Int_t' 0 '-1' lastzbin C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("ProjectionY",1142,G__G__Hist_308_0_45, 85, G__get_linked_tagnum(&G__G__HistLN_TH1D), -1, 0, 6, 1, 1, 8, 
"C - - 10 '\"_py\"' name i - 'Int_t' 0 '0' firstxbin "
"i - 'Int_t' 0 '-1' lastxbin i - 'Int_t' 0 '0' firstzbin "
"i - 'Int_t' 0 '-1' lastzbin C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("ProjectionZ",1143,G__G__Hist_308_0_46, 85, G__get_linked_tagnum(&G__G__HistLN_TH1D), -1, 0, 6, 1, 1, 8, 
"C - - 10 '\"_pz\"' name i - 'Int_t' 0 '0' firstxbin "
"i - 'Int_t' 0 '-1' lastxbin i - 'Int_t' 0 '0' firstybin "
"i - 'Int_t' 0 '-1' lastybin C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("Project3D",846,G__G__Hist_308_0_47, 85, G__get_linked_tagnum(&G__G__HistLN_TH1), -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"x\"' option", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("Project3DProfile",1567,G__G__Hist_308_0_48, 85, G__get_linked_tagnum(&G__G__HistLN_TProfile2D), -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"xy\"' option", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("PutStats",840,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - stats", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Reset",515,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetShowProjection",1770,G__G__Hist_308_0_51, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 '\"xy\"' option i - 'Int_t' 0 '1' nbins", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("DoProject1D",1023,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__HistLN_TH1D), -1, 0, 7, 1, 2, 8, 
"C - - 10 - name C - - 10 - title "
"U 'TAxis' - 0 - projX g - - 0 - computeErrors "
"g - - 0 - originalRange g - - 0 - useUF "
"g - - 0 - useOF", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoProject2D",1024,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__HistLN_TH2D), -1, 0, 8, 1, 2, 8, 
"C - - 10 - name C - - 10 - title "
"U 'TAxis' - 0 - projX U 'TAxis' - 0 - projY "
"g - - 0 - computeErrors g - - 0 - originalRange "
"g - - 0 - useUF g - - 0 - useOF", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoProjectProfile2D",1745,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__HistLN_TProfile2D), -1, 0, 7, 1, 2, 8, 
"C - - 10 - name C - - 10 - title "
"U 'TAxis' - 0 - projX U 'TAxis' - 0 - projY "
"g - - 0 - originalRange g - - 0 - useUF "
"g - - 0 - useOF", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Hist_308_0_55, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TH3::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_308_0_56, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH3::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_308_0_57, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TH3::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_308_0_58, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TH3::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_308_0_62, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_308_0_63, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH3::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_308_0_64, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TH3::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_308_0_65, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH3::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_308_0_66, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TH3::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TH3", 333, G__G__Hist_308_0_67, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTH3C(void) {
   /* TH3C */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TH3C));
   G__memfunc_setup("TH3C",274,G__G__Hist_309_0_1, 105, G__get_linked_tagnum(&G__G__HistLN_TH3C), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH3C",274,G__G__Hist_309_0_2, 105, G__get_linked_tagnum(&G__G__HistLN_TH3C), -1, 0, 11, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx d - 'Double_t' 0 - xlow "
"d - 'Double_t' 0 - xup i - 'Int_t' 0 - nbinsy "
"d - 'Double_t' 0 - ylow d - 'Double_t' 0 - yup "
"i - 'Int_t' 0 - nbinsz d - 'Double_t' 0 - zlow "
"d - 'Double_t' 0 - zup", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH3C",274,G__G__Hist_309_0_3, 105, G__get_linked_tagnum(&G__G__HistLN_TH3C), -1, 0, 8, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx F - 'Float_t' 10 - xbins "
"i - 'Int_t' 0 - nbinsy F - 'Float_t' 10 - ybins "
"i - 'Int_t' 0 - nbinsz F - 'Float_t' 10 - zbins", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH3C",274,G__G__Hist_309_0_4, 105, G__get_linked_tagnum(&G__G__HistLN_TH3C), -1, 0, 8, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx D - 'Double_t' 10 - xbins "
"i - 'Int_t' 0 - nbinsy D - 'Double_t' 10 - ybins "
"i - 'Int_t' 0 - nbinsz D - 'Double_t' 10 - zbins", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH3C",274,G__G__Hist_309_0_5, 105, G__get_linked_tagnum(&G__G__HistLN_TH3C), -1, 0, 1, 1, 1, 0, "u 'TH3C' - 11 - h3c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddBinContent",1277,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddBinContent",1277,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - bin d - 'Double_t' 0 - w", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TObject' - 1 - hnew", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawCopy",809,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TH1), -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinContent",1300,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinContent",1300,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - bin i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinContent",1300,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - binx i - 'Int_t' 0 - biny "
"i - 'Int_t' 0 - binz", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Reset",515,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinContent",1312,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - bin d - 'Double_t' 0 - content", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinContent",1312,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - bin i - 'Int_t' 0 - - "
"d - 'Double_t' 0 - content", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinContent",1312,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - binx i - 'Int_t' 0 - biny "
"i - 'Int_t' 0 - binz d - 'Double_t' 0 - content", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinsLength",1306,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '-1' n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator=",937,G__G__Hist_309_0_18, 117, G__get_linked_tagnum(&G__G__HistLN_TH3C), -1, 1, 1, 1, 1, 0, "u 'TH3C' - 11 - h1", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Hist_309_0_19, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TH3C::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_309_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH3C::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_309_0_21, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TH3C::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_309_0_22, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TH3C::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_309_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_309_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH3C::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_309_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TH3C::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_309_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH3C::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_309_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TH3C::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TH3C", 400, G__G__Hist_309_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTH3S(void) {
   /* TH3S */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TH3S));
   G__memfunc_setup("TH3S",290,G__G__Hist_310_0_1, 105, G__get_linked_tagnum(&G__G__HistLN_TH3S), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH3S",290,G__G__Hist_310_0_2, 105, G__get_linked_tagnum(&G__G__HistLN_TH3S), -1, 0, 11, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx d - 'Double_t' 0 - xlow "
"d - 'Double_t' 0 - xup i - 'Int_t' 0 - nbinsy "
"d - 'Double_t' 0 - ylow d - 'Double_t' 0 - yup "
"i - 'Int_t' 0 - nbinsz d - 'Double_t' 0 - zlow "
"d - 'Double_t' 0 - zup", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH3S",290,G__G__Hist_310_0_3, 105, G__get_linked_tagnum(&G__G__HistLN_TH3S), -1, 0, 8, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx F - 'Float_t' 10 - xbins "
"i - 'Int_t' 0 - nbinsy F - 'Float_t' 10 - ybins "
"i - 'Int_t' 0 - nbinsz F - 'Float_t' 10 - zbins", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH3S",290,G__G__Hist_310_0_4, 105, G__get_linked_tagnum(&G__G__HistLN_TH3S), -1, 0, 8, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx D - 'Double_t' 10 - xbins "
"i - 'Int_t' 0 - nbinsy D - 'Double_t' 10 - ybins "
"i - 'Int_t' 0 - nbinsz D - 'Double_t' 10 - zbins", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH3S",290,G__G__Hist_310_0_5, 105, G__get_linked_tagnum(&G__G__HistLN_TH3S), -1, 0, 1, 1, 1, 0, "u 'TH3S' - 11 - h3s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddBinContent",1277,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddBinContent",1277,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - bin d - 'Double_t' 0 - w", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TObject' - 1 - hnew", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawCopy",809,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TH1), -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinContent",1300,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinContent",1300,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - bin i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinContent",1300,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - binx i - 'Int_t' 0 - biny "
"i - 'Int_t' 0 - binz", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Reset",515,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinContent",1312,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - bin d - 'Double_t' 0 - content", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinContent",1312,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - bin i - 'Int_t' 0 - - "
"d - 'Double_t' 0 - content", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinContent",1312,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - binx i - 'Int_t' 0 - biny "
"i - 'Int_t' 0 - binz d - 'Double_t' 0 - content", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinsLength",1306,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '-1' n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator=",937,G__G__Hist_310_0_18, 117, G__get_linked_tagnum(&G__G__HistLN_TH3S), -1, 1, 1, 1, 1, 0, "u 'TH3S' - 11 - h1", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Hist_310_0_19, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TH3S::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_310_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH3S::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_310_0_21, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TH3S::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_310_0_22, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TH3S::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_310_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_310_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH3S::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_310_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TH3S::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_310_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH3S::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_310_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TH3S::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TH3S", 416, G__G__Hist_310_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTH3I(void) {
   /* TH3I */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TH3I));
   G__memfunc_setup("TH3I",280,G__G__Hist_311_0_1, 105, G__get_linked_tagnum(&G__G__HistLN_TH3I), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH3I",280,G__G__Hist_311_0_2, 105, G__get_linked_tagnum(&G__G__HistLN_TH3I), -1, 0, 11, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx d - 'Double_t' 0 - xlow "
"d - 'Double_t' 0 - xup i - 'Int_t' 0 - nbinsy "
"d - 'Double_t' 0 - ylow d - 'Double_t' 0 - yup "
"i - 'Int_t' 0 - nbinsz d - 'Double_t' 0 - zlow "
"d - 'Double_t' 0 - zup", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH3I",280,G__G__Hist_311_0_3, 105, G__get_linked_tagnum(&G__G__HistLN_TH3I), -1, 0, 8, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx F - 'Float_t' 10 - xbins "
"i - 'Int_t' 0 - nbinsy F - 'Float_t' 10 - ybins "
"i - 'Int_t' 0 - nbinsz F - 'Float_t' 10 - zbins", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH3I",280,G__G__Hist_311_0_4, 105, G__get_linked_tagnum(&G__G__HistLN_TH3I), -1, 0, 8, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx D - 'Double_t' 10 - xbins "
"i - 'Int_t' 0 - nbinsy D - 'Double_t' 10 - ybins "
"i - 'Int_t' 0 - nbinsz D - 'Double_t' 10 - zbins", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH3I",280,G__G__Hist_311_0_5, 105, G__get_linked_tagnum(&G__G__HistLN_TH3I), -1, 0, 1, 1, 1, 0, "u 'TH3I' - 11 - h3i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddBinContent",1277,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddBinContent",1277,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - bin d - 'Double_t' 0 - w", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TObject' - 1 - hnew", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawCopy",809,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TH1), -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinContent",1300,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinContent",1300,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - bin i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinContent",1300,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - binx i - 'Int_t' 0 - biny "
"i - 'Int_t' 0 - binz", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Reset",515,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinContent",1312,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - bin d - 'Double_t' 0 - content", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinContent",1312,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - bin i - 'Int_t' 0 - - "
"d - 'Double_t' 0 - content", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinContent",1312,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - binx i - 'Int_t' 0 - biny "
"i - 'Int_t' 0 - binz d - 'Double_t' 0 - content", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinsLength",1306,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '-1' n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator=",937,G__G__Hist_311_0_18, 117, G__get_linked_tagnum(&G__G__HistLN_TH3I), -1, 1, 1, 1, 1, 0, "u 'TH3I' - 11 - h1", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Hist_311_0_19, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TH3I::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_311_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH3I::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_311_0_21, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TH3I::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_311_0_22, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TH3I::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_311_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_311_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH3I::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_311_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TH3I::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_311_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH3I::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_311_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TH3I::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TH3I", 406, G__G__Hist_311_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTH3F(void) {
   /* TH3F */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TH3F));
   G__memfunc_setup("TH3F",277,G__G__Hist_312_0_1, 105, G__get_linked_tagnum(&G__G__HistLN_TH3F), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH3F",277,G__G__Hist_312_0_2, 105, G__get_linked_tagnum(&G__G__HistLN_TH3F), -1, 0, 11, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx d - 'Double_t' 0 - xlow "
"d - 'Double_t' 0 - xup i - 'Int_t' 0 - nbinsy "
"d - 'Double_t' 0 - ylow d - 'Double_t' 0 - yup "
"i - 'Int_t' 0 - nbinsz d - 'Double_t' 0 - zlow "
"d - 'Double_t' 0 - zup", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH3F",277,G__G__Hist_312_0_3, 105, G__get_linked_tagnum(&G__G__HistLN_TH3F), -1, 0, 8, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx F - 'Float_t' 10 - xbins "
"i - 'Int_t' 0 - nbinsy F - 'Float_t' 10 - ybins "
"i - 'Int_t' 0 - nbinsz F - 'Float_t' 10 - zbins", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH3F",277,G__G__Hist_312_0_4, 105, G__get_linked_tagnum(&G__G__HistLN_TH3F), -1, 0, 8, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx D - 'Double_t' 10 - xbins "
"i - 'Int_t' 0 - nbinsy D - 'Double_t' 10 - ybins "
"i - 'Int_t' 0 - nbinsz D - 'Double_t' 10 - zbins", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH3F",277,G__G__Hist_312_0_5, 105, G__get_linked_tagnum(&G__G__HistLN_TH3F), -1, 0, 1, 1, 1, 0, "u 'TH3F' - 11 - h3f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddBinContent",1277,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddBinContent",1277,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - bin d - 'Double_t' 0 - w", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TObject' - 1 - hnew", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawCopy",809,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TH1), -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinContent",1300,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinContent",1300,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - bin i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinContent",1300,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - binx i - 'Int_t' 0 - biny "
"i - 'Int_t' 0 - binz", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Reset",515,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinContent",1312,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - bin d - 'Double_t' 0 - content", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinContent",1312,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - bin i - 'Int_t' 0 - - "
"d - 'Double_t' 0 - content", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinContent",1312,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - binx i - 'Int_t' 0 - biny "
"i - 'Int_t' 0 - binz d - 'Double_t' 0 - content", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinsLength",1306,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '-1' n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator=",937,G__G__Hist_312_0_18, 117, G__get_linked_tagnum(&G__G__HistLN_TH3F), -1, 1, 1, 1, 1, 0, "u 'TH3F' - 11 - h1", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Hist_312_0_19, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TH3F::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_312_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH3F::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_312_0_21, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TH3F::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_312_0_22, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TH3F::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_312_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_312_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH3F::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_312_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TH3F::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_312_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH3F::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_312_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TH3F::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TH3F", 403, G__G__Hist_312_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTH3D(void) {
   /* TH3D */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TH3D));
   G__memfunc_setup("TH3D",275,G__G__Hist_313_0_1, 105, G__get_linked_tagnum(&G__G__HistLN_TH3D), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH3D",275,G__G__Hist_313_0_2, 105, G__get_linked_tagnum(&G__G__HistLN_TH3D), -1, 0, 11, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx d - 'Double_t' 0 - xlow "
"d - 'Double_t' 0 - xup i - 'Int_t' 0 - nbinsy "
"d - 'Double_t' 0 - ylow d - 'Double_t' 0 - yup "
"i - 'Int_t' 0 - nbinsz d - 'Double_t' 0 - zlow "
"d - 'Double_t' 0 - zup", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH3D",275,G__G__Hist_313_0_3, 105, G__get_linked_tagnum(&G__G__HistLN_TH3D), -1, 0, 8, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx F - 'Float_t' 10 - xbins "
"i - 'Int_t' 0 - nbinsy F - 'Float_t' 10 - ybins "
"i - 'Int_t' 0 - nbinsz F - 'Float_t' 10 - zbins", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH3D",275,G__G__Hist_313_0_4, 105, G__get_linked_tagnum(&G__G__HistLN_TH3D), -1, 0, 8, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx D - 'Double_t' 10 - xbins "
"i - 'Int_t' 0 - nbinsy D - 'Double_t' 10 - ybins "
"i - 'Int_t' 0 - nbinsz D - 'Double_t' 10 - zbins", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH3D",275,G__G__Hist_313_0_5, 105, G__get_linked_tagnum(&G__G__HistLN_TH3D), -1, 0, 1, 1, 1, 0, "u 'TH3D' - 11 - h3d", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddBinContent",1277,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddBinContent",1277,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - bin d - 'Double_t' 0 - w", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TObject' - 1 - hnew", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawCopy",809,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TH1), -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinContent",1300,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinContent",1300,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - bin i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinContent",1300,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - binx i - 'Int_t' 0 - biny "
"i - 'Int_t' 0 - binz", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Reset",515,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinContent",1312,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - bin d - 'Double_t' 0 - content", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinContent",1312,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - bin i - 'Int_t' 0 - - "
"d - 'Double_t' 0 - content", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinContent",1312,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - binx i - 'Int_t' 0 - biny "
"i - 'Int_t' 0 - binz d - 'Double_t' 0 - content", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinsLength",1306,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '-1' n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator=",937,G__G__Hist_313_0_18, 117, G__get_linked_tagnum(&G__G__HistLN_TH3D), -1, 1, 1, 1, 1, 0, "u 'TH3D' - 11 - h1", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Hist_313_0_19, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TH3D::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_313_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH3D::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_313_0_21, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TH3D::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_313_0_22, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TH3D::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_313_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_313_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH3D::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_313_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TH3D::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_313_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH3D::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_313_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TH3D::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TH3D", 401, G__G__Hist_313_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTHLimitsFinder(void) {
   /* THLimitsFinder */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_THLimitsFinder));
   G__memfunc_setup("THLimitsFinder",1382,G__G__Hist_314_0_1, 105, G__get_linked_tagnum(&G__G__HistLN_THLimitsFinder), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindGoodLimits",1404,G__G__Hist_314_0_2, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"U 'TH1' - 0 - h d - 'Double_t' 0 - xmin "
"d - 'Double_t' 0 - xmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindGoodLimits",1404,G__G__Hist_314_0_3, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 0, 
"U 'TH1' - 0 - h d - 'Double_t' 0 - xmin "
"d - 'Double_t' 0 - xmax d - 'Double_t' 0 - ymin "
"d - 'Double_t' 0 - ymax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindGoodLimits",1404,G__G__Hist_314_0_4, 105, -1, G__defined_typename("Int_t"), 0, 7, 1, 1, 0, 
"U 'TH1' - 0 - h d - 'Double_t' 0 - xmin "
"d - 'Double_t' 0 - xmax d - 'Double_t' 0 - ymin "
"d - 'Double_t' 0 - ymax d - 'Double_t' 0 - zmin "
"d - 'Double_t' 0 - zmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Optimize",849,G__G__Hist_314_0_5, 121, -1, -1, 0, 8, 3, 1, 0, 
"d - 'Double_t' 0 - A1 d - 'Double_t' 0 - A2 "
"i - 'Int_t' 0 - nold d - 'Double_t' 1 - BinLow "
"d - 'Double_t' 1 - BinHigh i - 'Int_t' 1 - nbins "
"d - 'Double_t' 1 - BWID C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) G__func2void( (void (*)(Double_t, Double_t, Int_t, Double_t&, Double_t&, Int_t&, Double_t&, Option_t*))(&THLimitsFinder::Optimize) ), 0);
   G__memfunc_setup("OptimizeLimits",1475,G__G__Hist_314_0_6, 121, -1, -1, 0, 5, 3, 1, 0, 
"i - 'Int_t' 0 - nbins i - 'Int_t' 1 - newbins "
"d - 'Double_t' 1 - xmin d - 'Double_t' 1 - xmax "
"g - 'Bool_t' 0 - isInteger", (char*)NULL, (void*) G__func2void( (void (*)(Int_t, Int_t&, Double_t&, Double_t&, Bool_t))(&THLimitsFinder::OptimizeLimits) ), 0);
   G__memfunc_setup("GetLimitsFinder",1514,G__G__Hist_314_0_7, 85, G__get_linked_tagnum(&G__G__HistLN_THLimitsFinder), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (THLimitsFinder* (*)())(&THLimitsFinder::GetLimitsFinder) ), 0);
   G__memfunc_setup("SetLimitsFinder",1526,G__G__Hist_314_0_8, 121, -1, -1, 0, 1, 3, 1, 0, "U 'THLimitsFinder' - 0 - finder", (char*)NULL, (void*) G__func2void( (void (*)(THLimitsFinder*))(&THLimitsFinder::SetLimitsFinder) ), 0);
   G__memfunc_setup("Class",502,G__G__Hist_314_0_9, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&THLimitsFinder::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_314_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THLimitsFinder::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_314_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&THLimitsFinder::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_314_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&THLimitsFinder::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_314_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_314_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THLimitsFinder::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_314_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THLimitsFinder::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_314_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THLimitsFinder::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_314_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THLimitsFinder::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("THLimitsFinder", 1382, G__G__Hist_314_0_21, (int) ('i'), G__get_linked_tagnum(&G__G__HistLN_THLimitsFinder), -1, 0, 1, 1, 1, 0, "u 'THLimitsFinder' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~THLimitsFinder", 1508, G__G__Hist_314_0_22, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Hist_314_0_23, (int) ('u'), G__get_linked_tagnum(&G__G__HistLN_THLimitsFinder), -1, 1, 1, 1, 1, 0, "u 'THLimitsFinder' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTHnSparseArrayChunk(void) {
   /* THnSparseArrayChunk */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_THnSparseArrayChunk));
   G__memfunc_setup("THnSparseArrayChunk",1904,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__HistLN_THnSparseArrayChunk), -1, 0, 1, 1, 4, 0, "u 'THnSparseArrayChunk' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__HistLN_THnSparseArrayChunk), -1, 1, 1, 1, 4, 0, "u 'THnSparseArrayChunk' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("THnSparseArrayChunk",1904,G__G__Hist_319_0_3, 105, G__get_linked_tagnum(&G__G__HistLN_THnSparseArrayChunk), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("THnSparseArrayChunk",1904,G__G__Hist_319_0_4, 105, G__get_linked_tagnum(&G__G__HistLN_THnSparseArrayChunk), -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - coordsize g - - 0 - errors "
"U 'TArray' - 0 - cont", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddBin",546,G__G__Hist_319_0_5, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - idx C - 'Char_t' 10 - idxbuf", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddBinContent",1277,G__G__Hist_319_0_6, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - idx d - 'Double_t' 0 '1.' v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Sumw2",478,G__G__Hist_319_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEntries",1018,G__G__Hist_319_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Matches",709,G__G__Hist_319_0_9, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - idx C - 'Char_t' 10 - idxbuf", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Hist_319_0_10, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&THnSparseArrayChunk::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_319_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THnSparseArrayChunk::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_319_0_12, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&THnSparseArrayChunk::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_319_0_13, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&THnSparseArrayChunk::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_319_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_319_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THnSparseArrayChunk::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_319_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THnSparseArrayChunk::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_319_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THnSparseArrayChunk::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_319_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THnSparseArrayChunk::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~THnSparseArrayChunk", 2030, G__G__Hist_319_0_22, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTHnSparseTlETArrayDgR(void) {
   /* THnSparseT<TArrayD> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArrayDgR));
   G__memfunc_setup("THnSparseT<TArrayD>",1757,G__G__Hist_322_0_1, 105, G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArrayDgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("THnSparseT<TArrayD>",1757,G__G__Hist_322_0_2, 105, G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArrayDgR), -1, 0, 7, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - dim I - 'Int_t' 10 - nbins "
"D - 'Double_t' 10 '0' xmin D - 'Double_t' 10 '0' xmax "
"i - 'Int_t' 0 '1024*16' chunksize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GenerateArray",1322,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TArray), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Hist_322_0_4, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&THnSparseT<TArrayD>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_322_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THnSparseT<TArrayD>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_322_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&THnSparseT<TArrayD>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_322_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&THnSparseT<TArrayD>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_322_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_322_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THnSparseT<TArrayD>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_322_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THnSparseT<TArrayD>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_322_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THnSparseT<TArrayD>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_322_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THnSparseT<TArrayD>::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~THnSparseT<TArrayD>", 1883, G__G__Hist_322_0_16, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTHnSparseTlETArrayFgR(void) {
   /* THnSparseT<TArrayF> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArrayFgR));
   G__memfunc_setup("THnSparseT<TArrayF>",1759,G__G__Hist_323_0_1, 105, G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArrayFgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("THnSparseT<TArrayF>",1759,G__G__Hist_323_0_2, 105, G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArrayFgR), -1, 0, 7, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - dim I - 'Int_t' 10 - nbins "
"D - 'Double_t' 10 '0' xmin D - 'Double_t' 10 '0' xmax "
"i - 'Int_t' 0 '1024*16' chunksize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GenerateArray",1322,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TArray), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Hist_323_0_4, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&THnSparseT<TArrayF>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_323_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THnSparseT<TArrayF>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_323_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&THnSparseT<TArrayF>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_323_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&THnSparseT<TArrayF>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_323_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_323_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THnSparseT<TArrayF>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_323_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THnSparseT<TArrayF>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_323_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THnSparseT<TArrayF>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_323_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THnSparseT<TArrayF>::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~THnSparseT<TArrayF>", 1885, G__G__Hist_323_0_16, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTHnSparseTlETArrayLgR(void) {
   /* THnSparseT<TArrayL> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArrayLgR));
   G__memfunc_setup("THnSparseT<TArrayL>",1765,G__G__Hist_324_0_1, 105, G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArrayLgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("THnSparseT<TArrayL>",1765,G__G__Hist_324_0_2, 105, G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArrayLgR), -1, 0, 7, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - dim I - 'Int_t' 10 - nbins "
"D - 'Double_t' 10 '0' xmin D - 'Double_t' 10 '0' xmax "
"i - 'Int_t' 0 '1024*16' chunksize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GenerateArray",1322,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TArray), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Hist_324_0_4, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&THnSparseT<TArrayL>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_324_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THnSparseT<TArrayL>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_324_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&THnSparseT<TArrayL>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_324_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&THnSparseT<TArrayL>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_324_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_324_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THnSparseT<TArrayL>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_324_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THnSparseT<TArrayL>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_324_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THnSparseT<TArrayL>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_324_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THnSparseT<TArrayL>::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~THnSparseT<TArrayL>", 1891, G__G__Hist_324_0_16, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTHnSparseTlETArrayIgR(void) {
   /* THnSparseT<TArrayI> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArrayIgR));
   G__memfunc_setup("THnSparseT<TArrayI>",1762,G__G__Hist_325_0_1, 105, G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArrayIgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("THnSparseT<TArrayI>",1762,G__G__Hist_325_0_2, 105, G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArrayIgR), -1, 0, 7, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - dim I - 'Int_t' 10 - nbins "
"D - 'Double_t' 10 '0' xmin D - 'Double_t' 10 '0' xmax "
"i - 'Int_t' 0 '1024*16' chunksize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GenerateArray",1322,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TArray), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Hist_325_0_4, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&THnSparseT<TArrayI>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_325_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THnSparseT<TArrayI>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_325_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&THnSparseT<TArrayI>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_325_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&THnSparseT<TArrayI>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_325_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_325_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THnSparseT<TArrayI>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_325_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THnSparseT<TArrayI>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_325_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THnSparseT<TArrayI>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_325_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THnSparseT<TArrayI>::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~THnSparseT<TArrayI>", 1888, G__G__Hist_325_0_16, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTHnSparseTlETArraySgR(void) {
   /* THnSparseT<TArrayS> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArraySgR));
   G__memfunc_setup("THnSparseT<TArrayS>",1772,G__G__Hist_326_0_1, 105, G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArraySgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("THnSparseT<TArrayS>",1772,G__G__Hist_326_0_2, 105, G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArraySgR), -1, 0, 7, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - dim I - 'Int_t' 10 - nbins "
"D - 'Double_t' 10 '0' xmin D - 'Double_t' 10 '0' xmax "
"i - 'Int_t' 0 '1024*16' chunksize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GenerateArray",1322,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TArray), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Hist_326_0_4, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&THnSparseT<TArrayS>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_326_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THnSparseT<TArrayS>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_326_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&THnSparseT<TArrayS>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_326_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&THnSparseT<TArrayS>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_326_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_326_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THnSparseT<TArrayS>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_326_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THnSparseT<TArrayS>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_326_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THnSparseT<TArrayS>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_326_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THnSparseT<TArrayS>::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~THnSparseT<TArrayS>", 1898, G__G__Hist_326_0_16, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTHnSparseTlETArrayCgR(void) {
   /* THnSparseT<TArrayC> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArrayCgR));
   G__memfunc_setup("THnSparseT<TArrayC>",1756,G__G__Hist_327_0_1, 105, G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArrayCgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("THnSparseT<TArrayC>",1756,G__G__Hist_327_0_2, 105, G__get_linked_tagnum(&G__G__HistLN_THnSparseTlETArrayCgR), -1, 0, 7, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - dim I - 'Int_t' 10 - nbins "
"D - 'Double_t' 10 '0' xmin D - 'Double_t' 10 '0' xmax "
"i - 'Int_t' 0 '1024*16' chunksize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GenerateArray",1322,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TArray), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Hist_327_0_4, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&THnSparseT<TArrayC>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_327_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THnSparseT<TArrayC>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_327_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&THnSparseT<TArrayC>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_327_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&THnSparseT<TArrayC>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_327_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_327_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THnSparseT<TArrayC>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_327_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THnSparseT<TArrayC>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_327_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THnSparseT<TArrayC>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_327_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THnSparseT<TArrayC>::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~THnSparseT<TArrayC>", 1882, G__G__Hist_327_0_16, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTHStack(void) {
   /* THStack */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_THStack));
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__HistLN_THStack), -1, 1, 1, 1, 4, 0, "u 'THStack' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("BuildStack",998,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("THStack",658,G__G__Hist_328_0_3, 105, G__get_linked_tagnum(&G__G__HistLN_THStack), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("THStack",658,G__G__Hist_328_0_4, 105, G__get_linked_tagnum(&G__G__HistLN_THStack), -1, 0, 2, 1, 1, 0, 
"C - - 10 - name C - - 10 - title", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("THStack",658,G__G__Hist_328_0_5, 105, G__get_linked_tagnum(&G__G__HistLN_THStack), -1, 0, 10, 1, 1, 0, 
"U 'TH1' - 10 - hist C - 'Option_t' 10 '\"x\"' axis "
"C - - 10 '0' name C - - 10 '0' title "
"i - 'Int_t' 0 '1' firstbin i - 'Int_t' 0 '-1' lastbin "
"i - 'Int_t' 0 '1' firstbin2 i - 'Int_t' 0 '-1' lastbin2 "
"C - 'Option_t' 10 '\"\"' proj_option C - 'Option_t' 10 '\"\"' draw_option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("THStack",658,G__G__Hist_328_0_6, 105, G__get_linked_tagnum(&G__G__HistLN_THStack), -1, 0, 1, 1, 1, 0, "u 'THStack' - 11 - hstack", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Add",265,G__G__Hist_328_0_7, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TH1' - 0 - h C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Browse",626,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TBrowser' - 0 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' chopt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetHistogram",1230,G__G__Hist_328_0_11, 85, G__get_linked_tagnum(&G__G__HistLN_TH1), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHists",811,G__G__Hist_328_0_12, 85, G__get_linked_tagnum(&G__G__HistLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStack",790,G__G__Hist_328_0_13, 85, G__get_linked_tagnum(&G__G__HistLN_TObjArray), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMaximum",1022,G__G__Hist_328_0_14, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMinimum",1020,G__G__Hist_328_0_15, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetXaxis",813,G__G__Hist_328_0_16, 85, G__get_linked_tagnum(&G__G__HistLN_TAxis), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetYaxis",814,G__G__Hist_328_0_17, 85, G__get_linked_tagnum(&G__G__HistLN_TAxis), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ls",223,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Modified",801,G__G__Hist_328_0_19, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' chopt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' chopt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RecursiveRemove",1574,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetHistogram",1242,G__G__Hist_328_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TH1' - 0 - h", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMaximum",1034,G__G__Hist_328_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 '-1111' maximum", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetMinimum",1032,G__G__Hist_328_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 '-1111' minimum", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Hist_328_0_27, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&THStack::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_328_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THStack::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_328_0_29, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&THStack::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_328_0_30, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&THStack::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_328_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_328_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THStack::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_328_0_36, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THStack::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_328_0_37, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THStack::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_328_0_38, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THStack::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~THStack", 784, G__G__Hist_328_0_39, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTKDE(void) {
   /* TKDE */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TKDE));
   G__memfunc_setup("TKDE",296,G__G__Hist_333_0_1, 105, G__get_linked_tagnum(&G__G__HistLN_TKDE), -1, 0, 6, 5, 1, 0, 
"h - 'UInt_t' 0 '0' events D - 'Double_t' 10 '0' data "
"d - 'Double_t' 0 '0.0' xMin d - 'Double_t' 0 '0.0' xMax "
"C - 'Option_t' 10 '\"KernelType:Gaussian;Iteration:Adaptive;Mirror:noMirror;Binning:RelaxedBinning\"' option d - 'Double_t' 0 '1.0' rho", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Fill",391,G__G__Hist_333_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - data", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetKernelType",1327,G__G__Hist_333_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TKDE::EKernelType' - 0 - kern", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetIteration",1243,G__G__Hist_333_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TKDE::EIteration' - 0 - iter", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMirror",935,G__G__Hist_333_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TKDE::EMirror' - 0 - mir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBinning",1009,G__G__Hist_333_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TKDE::EBinning' - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNBins",774,G__G__Hist_333_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - nbins", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetUseBinsNEvents",1704,G__G__Hist_333_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - nEvents", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTuneFactor",1319,G__G__Hist_333_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - rho", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRange",793,G__G__Hist_333_0_10, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - xMin d - 'Double_t' 0 - xMax", "By default computed from the data", (void*) NULL, 0);
   G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator()",957,G__G__Hist_333_0_12, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "d - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Hist_333_0_13, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"D - 'Double_t' 10 - x D - 'Double_t' 10 '0' p", "Needed for creating TF1", (void*) NULL, 0);
   G__memfunc_setup("GetValue",797,G__G__Hist_333_0_14, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "d - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetError",810,G__G__Hist_333_0_15, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "d - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBias",671,G__G__Hist_333_0_16, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "d - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMean",673,G__G__Hist_333_0_17, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSigma",785,G__G__Hist_333_0_18, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRAMISE",737,G__G__Hist_333_0_19, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFixedWeight",1400,G__G__Hist_333_0_20, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFunction",1126,G__G__Hist_333_0_21, 85, G__get_linked_tagnum(&G__G__HistLN_TF1), -1, 0, 3, 1, 1, 0, 
"h - 'UInt_t' 0 '100' npx d - 'Double_t' 0 '1.0' xMin "
"d - 'Double_t' 0 '0.0' xMax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetUpperFunction",1650,G__G__Hist_333_0_22, 85, G__get_linked_tagnum(&G__G__HistLN_TF1), -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 '0.95' confidenceLevel h - 'UInt_t' 0 '100' npx "
"d - 'Double_t' 0 '1.0' xMin d - 'Double_t' 0 '0.0' xMax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLowerFunction",1647,G__G__Hist_333_0_23, 85, G__get_linked_tagnum(&G__G__HistLN_TF1), -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 '0.95' confidenceLevel h - 'UInt_t' 0 '100' npx "
"d - 'Double_t' 0 '1.0' xMin d - 'Double_t' 0 '0.0' xMax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetApproximateBias",1833,G__G__Hist_333_0_24, 85, G__get_linked_tagnum(&G__G__HistLN_TF1), -1, 0, 3, 1, 1, 0, 
"h - 'UInt_t' 0 '100' npx d - 'Double_t' 0 '1.0' xMin "
"d - 'Double_t' 0 '0.0' xMax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGraphWithErrors",1835,G__G__Hist_333_0_25, 85, G__get_linked_tagnum(&G__G__HistLN_TGraphErrors), -1, 0, 3, 1, 1, 0, 
"h - 'UInt_t' 0 '100' npx d - 'Double_t' 0 '1.0' xMin "
"d - 'Double_t' 0 '0.0' xMax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDrawnFunction",1634,G__G__Hist_333_0_26, 85, G__get_linked_tagnum(&G__G__HistLN_TF1), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDrawnUpperFunction",2158,G__G__Hist_333_0_27, 85, G__get_linked_tagnum(&G__G__HistLN_TF1), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDrawnLowerFunction",2155,G__G__Hist_333_0_28, 85, G__get_linked_tagnum(&G__G__HistLN_TF1), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDrawnGraph",1294,G__G__Hist_333_0_29, 85, G__get_linked_tagnum(&G__G__HistLN_TGraphErrors), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAdaptiveWeights",1833,G__G__Hist_333_0_30, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TKDE",296,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__HistLN_TKDE), -1, 0, 1, 1, 4, 0, "u 'TKDE' - 1 - kde", "Disallowed copy constructor", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__HistLN_TKDE), -1, 0, 1, 1, 4, 0, "u 'TKDE' - 1 - kde", "Disallowed assign operator", (void*) NULL, 0);
   G__memfunc_setup("Instantiate",1156,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 7, 1, 4, 0, 
"U 'ROOT::Math::IBaseFunctionOneDim' 'TKDE::KernelFunction_Ptr' 0 - kernfunc h - 'UInt_t' 0 - events "
"D - 'Double_t' 10 - data d - 'Double_t' 0 - xMin "
"d - 'Double_t' 0 - xMax C - 'Option_t' 10 - option "
"d - 'Double_t' 0 - rho", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GaussianKernel",1436,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 4, 8, "d - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EpanechnikovKernel",1852,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 4, 8, "d - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BiweightKernel",1428,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 4, 8, "d - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CosineArchKernel",1600,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 4, 8, "d - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpperConfidenceInterval",2367,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 4, 8, 
"D - 'Double_t' 10 - x D - 'Double_t' 10 - p", "Valid if the bandwidth is small compared to nEvents**1/5", (void*) NULL, 0);
   G__memfunc_setup("LowerConfidenceInterval",2364,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 4, 8, 
"D - 'Double_t' 10 - x D - 'Double_t' 10 - p", "Valid if the bandwidth is small compared to nEvents**1/5", (void*) NULL, 0);
   G__memfunc_setup("ApproximateBias",1545,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 4, 8, 
"D - 'Double_t' 10 - x D - 'Double_t' 10 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ComputeKernelL2Norm",1880,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ComputeKernelSigma2",1889,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ComputeKernelMu",1536,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ComputeKernelIntegral",2164,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ComputeMidspread",1654,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Index",504,(G__InterfaceMethod) NULL, 104, -1, G__defined_typename("UInt_t"), 0, 1, 1, 4, 8, "d - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBinCentreData",1568,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
"d - 'Double_t' 0 - xmin d - 'Double_t' 0 - xmax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBinCountData",1480,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckKernelValidity",1925,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCanonicalBandwidth",2121,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetKernelSigma2",1456,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCanonicalBandwidths",2236,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetKernelSigmas2",1571,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetHistogram",1242,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetUseBins",997,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMirror",935,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMean",685,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSigma",797,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "d - 'Double_t' 0 - R", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetKernel",909,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetKernelFunction",1747,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'ROOT::Math::IBaseFunctionOneDim' 'TKDE::KernelFunction_Ptr' 0 '0' kernfunc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetOptions",1048,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
"C - 'Option_t' 10 - option d - 'Double_t' 0 - rho", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckOptions",1226,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "g - 'Bool_t' 0 'kFALSE' isUserDefinedKernel", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOptions",1036,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
"u 'string' - 0 - optionType u 'string' - 0 - option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AssureOptions",1375,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetData",678,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "D - 'Double_t' 10 - data", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InitFromNewData",1484,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMirroredEvents",1765,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDrawOptions",1446,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 4, 0, 
"C - 'Option_t' 10 - option u 'TString' - 1 - plotOpt "
"u 'TString' - 1 - drawOpt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawErrors",1035,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'TString' - 1 - drawOpt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawConfidenceInterval",2241,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
"u 'TString' - 1 - drawOpt d - - 0 '0.95' cl", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetKDEFunction",1338,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__HistLN_TF1), -1, 0, 3, 1, 4, 0, 
"h - 'UInt_t' 0 '100' npx d - 'Double_t' 0 '1.0' xMin "
"d - 'Double_t' 0 '0.0' xMax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetKDEApproximateBias",2045,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__HistLN_TF1), -1, 0, 3, 1, 4, 0, 
"h - 'UInt_t' 0 '100' npx d - 'Double_t' 0 '1.0' xMin "
"d - 'Double_t' 0 '0.0' xMax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPDFUpperConfidenceInterval",2873,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__HistLN_TF1), -1, 0, 4, 1, 4, 0, 
"d - 'Double_t' 0 '0.95' confidenceLevel h - 'UInt_t' 0 '100' npx "
"d - 'Double_t' 0 '1.0' xMin d - 'Double_t' 0 '0.0' xMax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPDFLowerConfidenceInterval",2870,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__HistLN_TF1), -1, 0, 4, 1, 4, 0, 
"d - 'Double_t' 0 '0.95' confidenceLevel h - 'UInt_t' 0 '100' npx "
"d - 'Double_t' 0 '1.0' xMin d - 'Double_t' 0 '0.0' xMax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Hist_333_0_75, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TKDE::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_333_0_76, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TKDE::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_333_0_77, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TKDE::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_333_0_78, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TKDE::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_333_0_82, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_333_0_83, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TKDE::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_333_0_84, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TKDE::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_333_0_85, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TKDE::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_333_0_86, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TKDE::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TKDE", 422, G__G__Hist_333_0_87, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTLimitDataSource(void) {
   /* TLimitDataSource */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TLimitDataSource));
   G__memfunc_setup("TLimitDataSource",1598,G__G__Hist_344_0_1, 105, G__get_linked_tagnum(&G__G__HistLN_TLimitDataSource), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TLimitDataSource",1598,G__G__Hist_344_0_2, 105, G__get_linked_tagnum(&G__G__HistLN_TLimitDataSource), -1, 0, 3, 1, 1, 0, 
"U 'TH1' - 0 - s U 'TH1' - 0 - b "
"U 'TH1' - 0 - d", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TLimitDataSource",1598,G__G__Hist_344_0_3, 105, G__get_linked_tagnum(&G__G__HistLN_TLimitDataSource), -1, 0, 6, 1, 1, 0, 
"U 'TH1' - 0 - s U 'TH1' - 0 - b "
"U 'TH1' - 0 - d U 'TVectorT<double>' 'TVectorD' 0 - es "
"U 'TVectorT<double>' 'TVectorD' 0 - eb U 'TObjArray' - 0 - names", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddChannel",962,G__G__Hist_344_0_4, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TH1' - 0 - - U 'TH1' - 0 - - "
"U 'TH1' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddChannel",962,G__G__Hist_344_0_5, 121, -1, -1, 0, 6, 1, 1, 0, 
"U 'TH1' - 0 - - U 'TH1' - 0 - - "
"U 'TH1' - 0 - - U 'TVectorT<double>' 'TVectorD' 0 - - "
"U 'TVectorT<double>' 'TVectorD' 0 - - U 'TObjArray' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSignal",894,G__G__Hist_344_0_6, 85, G__get_linked_tagnum(&G__G__HistLN_TObjArray), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBackground",1312,G__G__Hist_344_0_7, 85, G__get_linked_tagnum(&G__G__HistLN_TObjArray), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCandidates",1296,G__G__Hist_344_0_8, 85, G__get_linked_tagnum(&G__G__HistLN_TObjArray), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetErrorOnSignal",1605,G__G__Hist_344_0_9, 85, G__get_linked_tagnum(&G__G__HistLN_TObjArray), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetErrorOnBackground",2023,G__G__Hist_344_0_10, 85, G__get_linked_tagnum(&G__G__HistLN_TObjArray), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetErrorNames",1310,G__G__Hist_344_0_11, 85, G__get_linked_tagnum(&G__G__HistLN_TObjArray), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetOwner",823,G__G__Hist_344_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 'kTRUE' swtch", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Hist_344_0_13, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TLimitDataSource::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_344_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLimitDataSource::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_344_0_15, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TLimitDataSource::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_344_0_16, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TLimitDataSource::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_344_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_344_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLimitDataSource::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_344_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TLimitDataSource::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_344_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLimitDataSource::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_344_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TLimitDataSource::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TLimitDataSource", 1724, G__G__Hist_344_0_25, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTLimit(void) {
   /* TLimit */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TLimit));
   G__memfunc_setup("Fluctuate",941,(G__InterfaceMethod) NULL, 103, -1, -1, 0, 5, 3, 2, 0, 
"U 'TLimitDataSource' - 0 - input U 'TLimitDataSource' - 0 - output "
"g - - 0 - init U 'TRandom' - 0 - - "
"g - - 0 'false' stat", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LogLikelihood",1318,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 4, 3, 2, 0, 
"d - 'Double_t' 0 - s d - 'Double_t' 0 - b "
"d - 'Double_t' 0 - b2 d - 'Double_t' 0 - d", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TLimit",595,G__G__Hist_347_0_3, 105, G__get_linked_tagnum(&G__G__HistLN_TLimit), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ComputeLimit",1244,G__G__Hist_347_0_4, 85, G__get_linked_tagnum(&G__G__HistLN_TConfidenceLevel), -1, 0, 4, 3, 1, 0, 
"U 'TLimitDataSource' - 0 - data i - 'Int_t' 0 '50000' nmc "
"g - - 0 'false' stat U 'TRandom' - 0 '0' generator", (char*)NULL, (void*) G__func2void( (TConfidenceLevel* (*)(TLimitDataSource*, Int_t, bool, TRandom*))(&TLimit::ComputeLimit) ), 0);
   G__memfunc_setup("ComputeLimit",1244,G__G__Hist_347_0_5, 85, G__get_linked_tagnum(&G__G__HistLN_TConfidenceLevel), -1, 0, 6, 3, 1, 0, 
"d - 'Double_t' 0 - s d - 'Double_t' 0 - b "
"i - 'Int_t' 0 - d i - 'Int_t' 0 '50000' nmc "
"g - - 0 'false' stat U 'TRandom' - 0 '0' generator", (char*)NULL, (void*) G__func2void( (TConfidenceLevel* (*)(Double_t, Double_t, Int_t, Int_t, bool, TRandom*))(&TLimit::ComputeLimit) ), 0);
   G__memfunc_setup("ComputeLimit",1244,G__G__Hist_347_0_6, 85, G__get_linked_tagnum(&G__G__HistLN_TConfidenceLevel), -1, 0, 9, 3, 1, 0, 
"d - 'Double_t' 0 - s d - 'Double_t' 0 - b "
"i - 'Int_t' 0 - d U 'TVectorT<double>' 'TVectorD' 0 - se "
"U 'TVectorT<double>' 'TVectorD' 0 - be U 'TObjArray' - 0 - - "
"i - 'Int_t' 0 '50000' nmc g - - 0 'false' stat "
"U 'TRandom' - 0 '0' generator", (char*)NULL, (void*) G__func2void( (TConfidenceLevel* (*)(Double_t, Double_t, Int_t, TVectorD*, TVectorD*, TObjArray*, Int_t, bool, TRandom*))(&TLimit::ComputeLimit) ), 0);
   G__memfunc_setup("ComputeLimit",1244,G__G__Hist_347_0_7, 85, G__get_linked_tagnum(&G__G__HistLN_TConfidenceLevel), -1, 0, 6, 3, 1, 0, 
"U 'TH1' - 0 - s U 'TH1' - 0 - b "
"U 'TH1' - 0 - d i - 'Int_t' 0 '50000' nmc "
"g - - 0 'false' stat U 'TRandom' - 0 '0' generator", (char*)NULL, (void*) G__func2void( (TConfidenceLevel* (*)(TH1*, TH1*, TH1*, Int_t, bool, TRandom*))(&TLimit::ComputeLimit) ), 0);
   G__memfunc_setup("ComputeLimit",1244,G__G__Hist_347_0_8, 85, G__get_linked_tagnum(&G__G__HistLN_TConfidenceLevel), -1, 0, 9, 3, 1, 0, 
"U 'TH1' - 0 - s U 'TH1' - 0 - b "
"U 'TH1' - 0 - d U 'TVectorT<double>' 'TVectorD' 0 - se "
"U 'TVectorT<double>' 'TVectorD' 0 - be U 'TObjArray' - 0 - - "
"i - 'Int_t' 0 '50000' nmc g - - 0 'false' stat "
"U 'TRandom' - 0 '0' generator", (char*)NULL, (void*) G__func2void( (TConfidenceLevel* (*)(TH1*, TH1*, TH1*, TVectorD*, TVectorD*, TObjArray*, Int_t, bool, TRandom*))(&TLimit::ComputeLimit) ), 0);
   G__memfunc_setup("Class",502,G__G__Hist_347_0_9, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TLimit::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_347_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLimit::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_347_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TLimit::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_347_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TLimit::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Hist_347_0_13, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Hist_347_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Hist_347_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_347_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_347_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLimit::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_347_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TLimit::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_347_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLimit::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_347_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TLimit::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TLimit", 595, G__G__Hist_347_0_21, (int) ('i'), G__get_linked_tagnum(&G__G__HistLN_TLimit), -1, 0, 1, 1, 1, 0, "u 'TLimit' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TLimit", 721, G__G__Hist_347_0_22, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Hist_347_0_23, (int) ('u'), G__get_linked_tagnum(&G__G__HistLN_TLimit), -1, 1, 1, 1, 1, 0, "u 'TLimit' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMultiDimFit(void) {
   /* TMultiDimFit */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TMultiDimFit));
   G__memfunc_setup("EvalFactor",999,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 2, 8, 
"i - 'Int_t' 0 - p d - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("EvalControl",1129,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 2, 8, "I - 'Int_t' 10 - powers", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeCoefficientErrors",2138,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeCorrelation",1536,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeGramSchmidt",1489,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 2, 0, "i - 'Int_t' 0 - function", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeCoefficients",1616,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeCandidates",1390,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeNormalized",1427,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeParameterization",2077,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeRealCode",1149,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"C - - 10 - filename C - - 10 - classname "
"C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Select",608,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 2, 0, "I - 'Int_t' 10 - iv", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TestFunction",1254,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 2, 0, 
"d - 'Double_t' 0 - squareResidual d - 'Double_t' 0 - dResidur", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TMultiDimFit",1180,G__G__Hist_378_0_13, 105, G__get_linked_tagnum(&G__G__HistLN_TMultiDimFit), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMultiDimFit",1180,G__G__Hist_378_0_14, 105, G__get_linked_tagnum(&G__G__HistLN_TMultiDimFit), -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - dimension i 'TMultiDimFit::EMDFPolyType' - 0 'kMonomials' type "
"C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddRow",577,G__G__Hist_378_0_15, 121, -1, -1, 0, 3, 1, 1, 0, 
"D - 'Double_t' 10 - x d - 'Double_t' 0 - D "
"d - 'Double_t' 0 '0' E", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddTestRow",993,G__G__Hist_378_0_16, 121, -1, -1, 0, 3, 1, 1, 0, 
"D - 'Double_t' 10 - x d - 'Double_t' 0 - D "
"d - 'Double_t' 0 '0' E", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Browse",626,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TBrowser' - 0 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"d\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Eval",392,G__G__Hist_378_0_20, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"D - 'Double_t' 10 - x D - 'Double_t' 10 '0' coeff", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("EvalError",914,G__G__Hist_378_0_21, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"D - 'Double_t' 10 - x D - 'Double_t' 10 '0' coeff", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindParameterization",2080,G__G__Hist_378_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Fit",291,G__G__Hist_378_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("GetChi2",614,G__G__Hist_378_0_24, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCorrelationMatrix",2071,G__G__Hist_378_0_25, 85, G__get_linked_tagnum(&G__G__HistLN_TMatrixTlEdoublegR), G__defined_typename("TMatrixD"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCoefficients",1522,G__G__Hist_378_0_26, 85, G__get_linked_tagnum(&G__G__HistLN_TVectorTlEdoublegR), G__defined_typename("TVectorD"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetError",810,G__G__Hist_378_0_27, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFunctionCodes",1620,G__G__Hist_378_0_28, 73, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFunctions",1241,G__G__Hist_378_0_29, 85, G__get_linked_tagnum(&G__G__HistLN_TMatrixTlEdoublegR), G__defined_typename("TMatrixD"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHistograms",1345,G__G__Hist_378_0_30, 85, G__get_linked_tagnum(&G__G__HistLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMaxAngle",1069,G__G__Hist_378_0_31, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMaxFunctions",1535,G__G__Hist_378_0_32, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMaxPowers",1222,G__G__Hist_378_0_33, 73, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMaxQuantity",1445,G__G__Hist_378_0_34, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMaxStudy",1119,G__G__Hist_378_0_35, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMaxTerms",1105,G__G__Hist_378_0_36, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMaxVariables",1503,G__G__Hist_378_0_37, 85, G__get_linked_tagnum(&G__G__HistLN_TVectorTlEdoublegR), G__defined_typename("TVectorD"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMeanQuantity",1536,G__G__Hist_378_0_38, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMeanVariables",1594,G__G__Hist_378_0_39, 85, G__get_linked_tagnum(&G__G__HistLN_TVectorTlEdoublegR), G__defined_typename("TVectorD"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMinAngle",1067,G__G__Hist_378_0_40, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMinQuantity",1443,G__G__Hist_378_0_41, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMinRelativeError",1930,G__G__Hist_378_0_42, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMinVariables",1501,G__G__Hist_378_0_43, 85, G__get_linked_tagnum(&G__G__HistLN_TVectorTlEdoublegR), G__defined_typename("TVectorD"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNVariables",1287,G__G__Hist_378_0_44, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNCoefficients",1600,G__G__Hist_378_0_45, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPolyType",1126,G__G__Hist_378_0_46, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPowerIndex",1317,G__G__Hist_378_0_47, 73, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPowerLimit",1324,G__G__Hist_378_0_48, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPowers",928,G__G__Hist_378_0_49, 73, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPrecision",1228,G__G__Hist_378_0_50, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetQuantity",1151,G__G__Hist_378_0_51, 85, G__get_linked_tagnum(&G__G__HistLN_TVectorTlEdoublegR), G__defined_typename("TVectorD"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetResidualMax",1407,G__G__Hist_378_0_52, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetResidualMin",1405,G__G__Hist_378_0_53, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetResidualMaxRow",1719,G__G__Hist_378_0_54, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetResidualMinRow",1717,G__G__Hist_378_0_55, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetResidualSumSq",1618,G__G__Hist_378_0_56, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRMS",530,G__G__Hist_378_0_57, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSampleSize",1309,G__G__Hist_378_0_58, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSqError",1006,G__G__Hist_378_0_59, 85, G__get_linked_tagnum(&G__G__HistLN_TVectorTlEdoublegR), G__defined_typename("TVectorD"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSumSqAvgQuantity",1942,G__G__Hist_378_0_60, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSumSqQuantity",1656,G__G__Hist_378_0_61, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTestError",1226,G__G__Hist_378_0_62, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTestPrecision",1644,G__G__Hist_378_0_63, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTestQuantity",1567,G__G__Hist_378_0_64, 85, G__get_linked_tagnum(&G__G__HistLN_TVectorTlEdoublegR), G__defined_typename("TVectorD"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTestSampleSize",1725,G__G__Hist_378_0_65, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTestSqError",1422,G__G__Hist_378_0_66, 85, G__get_linked_tagnum(&G__G__HistLN_TVectorTlEdoublegR), G__defined_typename("TVectorD"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTestVariables",1625,G__G__Hist_378_0_67, 85, G__get_linked_tagnum(&G__G__HistLN_TVectorTlEdoublegR), G__defined_typename("TVectorD"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVariables",1209,G__G__Hist_378_0_68, 85, G__get_linked_tagnum(&G__G__HistLN_TVectorTlEdoublegR), G__defined_typename("TVectorD"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Instance",821,G__G__Hist_378_0_69, 85, G__get_linked_tagnum(&G__G__HistLN_TMultiDimFit), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TMultiDimFit* (*)())(&TMultiDimFit::Instance) ), 0);
   G__memfunc_setup("IsFolder",792,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeChi2",708,G__G__Hist_378_0_71, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "D - 'Double_t' 10 '0' coeff", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeCode",761,G__G__Hist_378_0_72, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 '\"MDF\"' functionName C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("MakeHistograms",1439,G__G__Hist_378_0_73, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"A\"' option", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("MakeMethod",991,G__G__Hist_378_0_74, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - 'Char_t' 10 '\"MDF\"' className C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"ps\"' option", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetBinVarX",966,G__G__Hist_378_0_76, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - nbbinvarx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBinVarY",967,G__G__Hist_378_0_77, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - nbbinvary", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMaxAngle",1081,G__G__Hist_378_0_78, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 '0' angle", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMaxFunctions",1547,G__G__Hist_378_0_79, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMaxPowers",1234,G__G__Hist_378_0_80, 121, -1, -1, 0, 1, 1, 1, 0, "I - 'Int_t' 10 - powers", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMaxStudy",1131,G__G__Hist_378_0_81, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMaxTerms",1117,G__G__Hist_378_0_82, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - terms", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMinRelativeError",1942,G__G__Hist_378_0_83, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - error", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMinAngle",1079,G__G__Hist_378_0_84, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 '1' angle", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPowerLimit",1336,G__G__Hist_378_0_85, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 '1e-3' limit", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPowers",940,G__G__Hist_378_0_86, 121, -1, -1, 0, 2, 1, 1, 0, 
"I - 'Int_t' 10 - powers i - 'Int_t' 0 - terms", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Hist_378_0_87, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMultiDimFit::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_378_0_88, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMultiDimFit::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_378_0_89, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMultiDimFit::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_378_0_90, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMultiDimFit::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_378_0_94, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_378_0_95, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMultiDimFit::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_378_0_96, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMultiDimFit::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_378_0_97, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMultiDimFit::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_378_0_98, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMultiDimFit::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TMultiDimFit", 1180, G__G__Hist_378_0_99, (int) ('i'), G__get_linked_tagnum(&G__G__HistLN_TMultiDimFit), -1, 0, 1, 1, 1, 0, "u 'TMultiDimFit' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TMultiDimFit", 1306, G__G__Hist_378_0_100, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Hist_378_0_101, (int) ('u'), G__get_linked_tagnum(&G__G__HistLN_TMultiDimFit), -1, 1, 1, 1, 1, 0, "u 'TMultiDimFit' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTPolyMarker(void) {
   /* TPolyMarker */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TPolyMarker));
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__HistLN_TPolyMarker), -1, 1, 1, 1, 2, 0, "u 'TPolyMarker' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPolyMarker",1114,G__G__Hist_380_0_2, 105, G__get_linked_tagnum(&G__G__HistLN_TPolyMarker), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPolyMarker",1114,G__G__Hist_380_0_3, 105, G__get_linked_tagnum(&G__G__HistLN_TPolyMarker), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - n C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPolyMarker",1114,G__G__Hist_380_0_4, 105, G__get_linked_tagnum(&G__G__HistLN_TPolyMarker), -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - n F - 'Float_t' 0 - x "
"F - 'Float_t' 0 - y C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPolyMarker",1114,G__G__Hist_380_0_5, 105, G__get_linked_tagnum(&G__G__HistLN_TPolyMarker), -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - n D - 'Double_t' 0 - x "
"D - 'Double_t' 0 - y C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPolyMarker",1114,G__G__Hist_380_0_6, 105, G__get_linked_tagnum(&G__G__HistLN_TPolyMarker), -1, 0, 1, 1, 1, 0, "u 'TPolyMarker' - 11 - polymarker", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TObject' - 1 - polymarker", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawPolyMarker",1428,G__G__Hist_380_0_10, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - n D - 'Double_t' 0 - x "
"D - 'Double_t' 0 - y C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLastPoint",1214,G__G__Hist_380_0_12, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetN",366,G__G__Hist_380_0_13, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetOption",921,(G__InterfaceMethod) NULL,67, -1, G__defined_typename("Option_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetX",376,G__G__Hist_380_0_15, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetY",377,G__G__Hist_380_0_16, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ls",223,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Merge",496,G__G__Hist_380_0_18, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TCollection' - 0 - list", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PaintPolyMarker",1538,G__G__Hist_380_0_20, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - n D - 'Double_t' 0 - x "
"D - 'Double_t' 0 - y C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetNextPoint",1237,G__G__Hist_380_0_23, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetPoint",822,G__G__Hist_380_0_24, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - point d - 'Double_t' 0 - x "
"d - 'Double_t' 0 - y", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetPolyMarker",1330,G__G__Hist_380_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPolyMarker",1330,G__G__Hist_380_0_26, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - n F - 'Float_t' 0 - x "
"F - 'Float_t' 0 - y C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPolyMarker",1330,G__G__Hist_380_0_27, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - n D - 'Double_t' 0 - x "
"D - 'Double_t' 0 - y C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Size",411,G__G__Hist_380_0_28, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Hist_380_0_29, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TPolyMarker::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_380_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPolyMarker::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_380_0_31, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TPolyMarker::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_380_0_32, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TPolyMarker::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_380_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_380_0_37, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPolyMarker::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_380_0_38, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPolyMarker::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_380_0_39, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPolyMarker::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_380_0_40, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPolyMarker::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TPolyMarker", 1240, G__G__Hist_380_0_41, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTPrincipal(void) {
   /* TPrincipal */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TPrincipal));
   G__memfunc_setup("TPrincipal",1014,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__HistLN_TPrincipal), -1, 0, 1, 1, 2, 0, "u 'TPrincipal' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__HistLN_TPrincipal), -1, 1, 1, 1, 2, 0, "u 'TPrincipal' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeNormalised",1420,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeRealCode",1149,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"C - - 10 - filename C - - 10 - prefix "
"C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPrincipal",1014,G__G__Hist_381_0_5, 105, G__get_linked_tagnum(&G__G__HistLN_TPrincipal), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPrincipal",1014,G__G__Hist_381_0_6, 105, G__get_linked_tagnum(&G__G__HistLN_TPrincipal), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - nVariables C - 'Option_t' 10 '\"ND\"' opt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddRow",577,G__G__Hist_381_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - x", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Browse",626,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TBrowser' - 0 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCovarianceMatrix",1936,G__G__Hist_381_0_10, 85, G__get_linked_tagnum(&G__G__HistLN_TMatrixTlEdoublegR), G__defined_typename("TMatrixD"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEigenValues",1400,G__G__Hist_381_0_11, 85, G__get_linked_tagnum(&G__G__HistLN_TVectorTlEdoublegR), G__defined_typename("TVectorD"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEigenVectors",1518,G__G__Hist_381_0_12, 85, G__get_linked_tagnum(&G__G__HistLN_TMatrixTlEdoublegR), G__defined_typename("TMatrixD"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHistograms",1345,G__G__Hist_381_0_13, 85, G__get_linked_tagnum(&G__G__HistLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMeanValues",1297,G__G__Hist_381_0_14, 85, G__get_linked_tagnum(&G__G__HistLN_TVectorTlEdoublegR), G__defined_typename("TVectorD"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRow",600,G__G__Hist_381_0_15, 68, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 1, "i - 'Int_t' 0 - row", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSigmas",900,G__G__Hist_381_0_16, 85, G__get_linked_tagnum(&G__G__HistLN_TVectorTlEdoublegR), G__defined_typename("TVectorD"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetUserData",1081,G__G__Hist_381_0_17, 85, G__get_linked_tagnum(&G__G__HistLN_TVectorTlEdoublegR), G__defined_typename("TVectorD"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsFolder",792,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeCode",761,G__G__Hist_381_0_19, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 '\"pca\"' filename C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("MakeHistograms",1439,G__G__Hist_381_0_20, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 '\"pca\"' name C - 'Option_t' 10 '\"epsdx\"' option", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("MakeMethods",1106,G__G__Hist_381_0_21, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 '\"PCA\"' classname C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("MakePrincipals",1427,G__G__Hist_381_0_22, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("P2X",218,G__G__Hist_381_0_23, 121, -1, -1, 0, 3, 1, 1, 0, 
"D - 'Double_t' 10 - p D - 'Double_t' 0 - x "
"i - 'Int_t' 0 - nTest", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"MSE\"' opt", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SumOfSquareResiduals",2055,G__G__Hist_381_0_25, 121, -1, -1, 0, 2, 1, 1, 0, 
"D - 'Double_t' 10 - x D - 'Double_t' 0 - s", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Test",416,G__G__Hist_381_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("X2P",218,G__G__Hist_381_0_27, 121, -1, -1, 0, 2, 1, 1, 0, 
"D - 'Double_t' 10 - x D - 'Double_t' 0 - p", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Hist_381_0_28, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TPrincipal::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_381_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPrincipal::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_381_0_30, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TPrincipal::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_381_0_31, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TPrincipal::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_381_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_381_0_36, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPrincipal::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_381_0_37, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPrincipal::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_381_0_38, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPrincipal::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_381_0_39, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPrincipal::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TPrincipal", 1140, G__G__Hist_381_0_40, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTProfile3D(void) {
   /* TProfile3D */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TProfile3D));
   G__memfunc_setup("BufferFill",993,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 2, 0, 
"d - 'Double_t' 0 - - d - 'Double_t' 0 - -", "may not use", (void*) NULL, 1);
   G__memfunc_setup("BufferFill",993,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 2, 0, 
"d - 'Double_t' 0 - - d - 'Double_t' 0 - - "
"d - 'Double_t' 0 - -", "may not use", (void*) NULL, 1);
   G__memfunc_setup("BufferFill",993,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 4, 1, 2, 0, 
"d - 'Double_t' 0 - - d - 'Double_t' 0 - - "
"d - 'Double_t' 0 - - d - 'Double_t' 0 - -", "may not use", (void*) NULL, 1);
   G__memfunc_setup("BufferFill",993,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 2, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"d - 'Double_t' 0 - z d - 'Double_t' 0 - t "
"d - 'Double_t' 0 - w", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBins",696,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"I - 'Int_t' 10 - nbins D - 'Double_t' 10 - range", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Fill",391,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 0, "D - 'Double_t' 10 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetB",354,(G__InterfaceMethod) NULL, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetB2",404,(G__InterfaceMethod) NULL, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetW",375,(G__InterfaceMethod) NULL, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetW2",425,(G__InterfaceMethod) NULL, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBins",696,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 4, 0, 
"i - 'Int_t' 0 - - d - 'Double_t' 0 - - "
"d - 'Double_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBins",696,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
"i - 'Int_t' 0 - - D - 'Double_t' 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBins",696,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 6, 1, 4, 0, 
"i - 'Int_t' 0 - - d - 'Double_t' 0 - - "
"d - 'Double_t' 0 - - i - 'Int_t' 0 - - "
"d - 'Double_t' 0 - - d - 'Double_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBins",696,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 4, 0, 
"i - 'Int_t' 0 - - D - 'Double_t' 10 - - "
"i - 'Int_t' 0 - - D - 'Double_t' 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBins",696,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 6, 1, 4, 0, 
"i - 'Int_t' 0 - - D - 'Double_t' 10 - - "
"i - 'Int_t' 0 - - D - 'Double_t' 10 - - "
"i - 'Int_t' 0 - - D - 'Double_t' 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TProfile3D",924,G__G__Hist_384_0_16, 105, G__get_linked_tagnum(&G__G__HistLN_TProfile3D), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TProfile3D",924,G__G__Hist_384_0_17, 105, G__get_linked_tagnum(&G__G__HistLN_TProfile3D), -1, 0, 12, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx d - 'Double_t' 0 - xlow "
"d - 'Double_t' 0 - xup i - 'Int_t' 0 - nbinsy "
"d - 'Double_t' 0 - ylow d - 'Double_t' 0 - yup "
"i - 'Int_t' 0 - nbinsz d - 'Double_t' 0 - zlow "
"d - 'Double_t' 0 - zup C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TProfile3D",924,G__G__Hist_384_0_18, 105, G__get_linked_tagnum(&G__G__HistLN_TProfile3D), -1, 0, 9, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nbinsx D - 'Double_t' 10 - xbins "
"i - 'Int_t' 0 - nbinsy D - 'Double_t' 10 - ybins "
"i - 'Int_t' 0 - nbinsz D - 'Double_t' 10 - zbins "
"C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TProfile3D",924,G__G__Hist_384_0_19, 105, G__get_linked_tagnum(&G__G__HistLN_TProfile3D), -1, 0, 1, 1, 1, 0, "u 'TProfile3D' - 11 - profile", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Add",265,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TF1' - 0 - h1 d - 'Double_t' 0 '1' c1 "
"C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Add",265,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TH1' - 10 - h1 d - 'Double_t' 0 '1' c1", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Add",265,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 0, 
"U 'TH1' - 10 - h1 U 'TH1' - 10 - h2 "
"d - 'Double_t' 0 '1' c1 d - 'Double_t' 0 '1' c2", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Approximate",1162,G__G__Hist_384_0_23, 121, -1, -1, 0, 1, 3, 1, 0, "g - 'Bool_t' 0 'kTRUE' approx", (char*)NULL, (void*) G__func2void( (void (*)(Bool_t))(&TProfile3D::Approximate) ), 0);
   G__memfunc_setup("BuildOptions",1244,G__G__Hist_384_0_24, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - tmin d - 'Double_t' 0 - tmax "
"C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BufferEmpty",1129,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 '0' action", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TObject' - 1 - hnew", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Divide",597,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TF1' - 0 - h1 d - 'Double_t' 0 '1' c1", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Divide",597,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TH1' - 10 - h1", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Divide",597,(G__InterfaceMethod) NULL,121, -1, -1, 0, 5, 1, 1, 0, 
"U 'TH1' - 10 - h1 U 'TH1' - 10 - h2 "
"d - 'Double_t' 0 '1' c1 d - 'Double_t' 0 '1' c2 "
"C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("DrawCopy",809,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TH1), -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Fill",391,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - -", "MayNotUse", (void*) NULL, 1);
   G__memfunc_setup("Fill",391,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"C - - 10 - - d - 'Double_t' 0 - -", "MayNotUse", (void*) NULL, 1);
   G__memfunc_setup("Fill",391,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - - d - 'Double_t' 0 - -", "MayNotUse", (void*) NULL, 1);
   G__memfunc_setup("Fill",391,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - - d - 'Double_t' 0 - - "
"d - 'Double_t' 0 - -", "MayNotUse", (void*) NULL, 1);
   G__memfunc_setup("Fill",391,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
"C - - 10 - - C - - 10 - - "
"C - - 10 - - d - 'Double_t' 0 - -", "MayNotUse", (void*) NULL, 1);
   G__memfunc_setup("Fill",391,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
"C - - 10 - - d - 'Double_t' 0 - - "
"C - - 10 - - d - 'Double_t' 0 - -", "MayNotUse", (void*) NULL, 1);
   G__memfunc_setup("Fill",391,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
"C - - 10 - - C - - 10 - - "
"d - 'Double_t' 0 - - d - 'Double_t' 0 - -", "MayNotUse", (void*) NULL, 1);
   G__memfunc_setup("Fill",391,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - - C - - 10 - - "
"C - - 10 - - d - 'Double_t' 0 - -", "MayNotUse", (void*) NULL, 1);
   G__memfunc_setup("Fill",391,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - - C - - 10 - - "
"d - 'Double_t' 0 - - d - 'Double_t' 0 - -", "MayNotUse", (void*) NULL, 1);
   G__memfunc_setup("Fill",391,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - - d - 'Double_t' 0 - - "
"C - - 10 - - d - 'Double_t' 0 - -", "MayNotUse", (void*) NULL, 1);
   G__memfunc_setup("Fill",391,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"d - 'Double_t' 0 - z d - 'Double_t' 0 - t", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Fill",391,G__G__Hist_384_0_42, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"d - 'Double_t' 0 - z d - 'Double_t' 0 - t "
"d - 'Double_t' 0 - w", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinContent",1300,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinContent",1300,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - - i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinContent",1300,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - binx i - 'Int_t' 0 - biny "
"i - 'Int_t' 0 - binz", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinError",1091,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinError",1091,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - - i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinError",1091,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - binx i - 'Int_t' 0 - biny "
"i - 'Int_t' 0 - binz", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinEntries",1299,G__G__Hist_384_0_49, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinEffectiveEntries",2212,G__G__Hist_384_0_50, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinSumw2",1047,G__G__Hist_384_0_51, 85, G__get_linked_tagnum(&G__G__HistLN_TArrayD), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinSumw2",1047,G__G__Hist_384_0_52, 85, G__get_linked_tagnum(&G__G__HistLN_TArrayD), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetErrorOption",1443,G__G__Hist_384_0_53, 67, -1, G__defined_typename("Option_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStats",815,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - stats", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTmin",696,G__G__Hist_384_0_55, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTmax",698,G__G__Hist_384_0_56, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Merge",496,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 1, 1, 1, 0, "U 'TCollection' - 0 - list", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Multiply",864,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TF1' - 0 - h1 d - 'Double_t' 0 '1' c1", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Multiply",864,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TH1' - 10 - h1", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Multiply",864,(G__InterfaceMethod) NULL,121, -1, -1, 0, 5, 1, 1, 0, 
"U 'TH1' - 10 - h1 U 'TH1' - 10 - h2 "
"d - 'Double_t' 0 '1' c1 d - 'Double_t' 0 '1' c2 "
"C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("ProjectionXYZ",1320,G__G__Hist_384_0_61, 85, G__get_linked_tagnum(&G__G__HistLN_TH3D), -1, 0, 2, 1, 1, 8, 
"C - - 10 '\"_pxyz\"' name C - 'Option_t' 10 '\"e\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PutStats",840,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - stats", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Reset",515,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RebinAxis",901,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - x U 'TAxis' - 0 - axis", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Scale",488,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 '1' c1 C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBinEntries",1311,G__G__Hist_384_0_67, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - bin d - 'Double_t' 0 - w", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBins",696,(G__InterfaceMethod) NULL,121, -1, -1, 0, 9, 1, 1, 0, 
"i - 'Int_t' 0 - nbinsx d - 'Double_t' 0 - xmin "
"d - 'Double_t' 0 - xmax i - 'Int_t' 0 - nbinsy "
"d - 'Double_t' 0 - ymin d - 'Double_t' 0 - ymax "
"i - 'Int_t' 0 - nbinsz d - 'Double_t' 0 - zmin "
"d - 'Double_t' 0 - zmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBuffer",902,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - buffersize C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetErrorOption",1455,G__G__Hist_384_0_70, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Sumw2",478,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Hist_384_0_72, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TProfile3D::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_384_0_73, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProfile3D::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_384_0_74, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TProfile3D::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_384_0_75, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TProfile3D::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_384_0_79, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_384_0_80, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProfile3D::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_384_0_81, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProfile3D::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_384_0_82, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProfile3D::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_384_0_83, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProfile3D::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TProfile3D", 1050, G__G__Hist_384_0_84, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTSplinePoly(void) {
   /* TSplinePoly */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TSplinePoly));
   G__memfunc_setup("TSplinePoly",1123,G__G__Hist_385_0_1, 105, G__get_linked_tagnum(&G__G__HistLN_TSplinePoly), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TSplinePoly",1123,G__G__Hist_385_0_2, 105, G__get_linked_tagnum(&G__G__HistLN_TSplinePoly), -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TSplinePoly",1123,G__G__Hist_385_0_3, 105, G__get_linked_tagnum(&G__G__HistLN_TSplinePoly), -1, 0, 1, 1, 1, 0, "u 'TSplinePoly' - 41 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Hist_385_0_4, 117, G__get_linked_tagnum(&G__G__HistLN_TSplinePoly), -1, 1, 1, 1, 1, 0, "u 'TSplinePoly' - 41 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("X",88,G__G__Hist_385_0_5, 100, -1, G__defined_typename("Double_t"), 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Y",89,G__G__Hist_385_0_6, 100, -1, G__defined_typename("Double_t"), 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetKnot",700,G__G__Hist_385_0_7, 121, -1, -1, 0, 2, 1, 1, 8, 
"d - 'Double_t' 1 - x d - 'Double_t' 1 - y", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Eval",392,G__G__Hist_385_0_8, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "d - 'Double_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CopyPoly",831,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'TSplinePoly' - 41 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Hist_385_0_10, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TSplinePoly::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_385_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSplinePoly::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_385_0_12, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TSplinePoly::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_385_0_13, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TSplinePoly::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_385_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_385_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSplinePoly::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_385_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSplinePoly::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_385_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSplinePoly::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_385_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSplinePoly::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TSplinePoly", 1249, G__G__Hist_385_0_22, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTSplinePoly3(void) {
   /* TSplinePoly3 */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TSplinePoly3));
   G__memfunc_setup("TSplinePoly3",1174,G__G__Hist_386_0_1, 105, G__get_linked_tagnum(&G__G__HistLN_TSplinePoly3), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TSplinePoly3",1174,G__G__Hist_386_0_2, 105, G__get_linked_tagnum(&G__G__HistLN_TSplinePoly3), -1, 0, 5, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"d - 'Double_t' 0 - b d - 'Double_t' 0 - c "
"d - 'Double_t' 0 - d", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TSplinePoly3",1174,G__G__Hist_386_0_3, 105, G__get_linked_tagnum(&G__G__HistLN_TSplinePoly3), -1, 0, 1, 1, 1, 0, "u 'TSplinePoly3' - 41 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Hist_386_0_4, 117, G__get_linked_tagnum(&G__G__HistLN_TSplinePoly3), -1, 1, 1, 1, 1, 0, "u 'TSplinePoly3' - 41 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("B",66,G__G__Hist_386_0_5, 100, -1, G__defined_typename("Double_t"), 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("C",67,G__G__Hist_386_0_6, 100, -1, G__defined_typename("Double_t"), 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("D",68,G__G__Hist_386_0_7, 100, -1, G__defined_typename("Double_t"), 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Eval",392,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "d - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Derivative",1043,G__G__Hist_386_0_9, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "d - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CopyPoly",831,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'TSplinePoly3' - 41 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Hist_386_0_11, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TSplinePoly3::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_386_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSplinePoly3::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_386_0_13, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TSplinePoly3::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_386_0_14, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TSplinePoly3::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_386_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_386_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSplinePoly3::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_386_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSplinePoly3::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_386_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSplinePoly3::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_386_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSplinePoly3::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TSplinePoly3", 1300, G__G__Hist_386_0_23, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTSplinePoly5(void) {
   /* TSplinePoly5 */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TSplinePoly5));
   G__memfunc_setup("TSplinePoly5",1176,G__G__Hist_387_0_1, 105, G__get_linked_tagnum(&G__G__HistLN_TSplinePoly5), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TSplinePoly5",1176,G__G__Hist_387_0_2, 105, G__get_linked_tagnum(&G__G__HistLN_TSplinePoly5), -1, 0, 7, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"d - 'Double_t' 0 - b d - 'Double_t' 0 - c "
"d - 'Double_t' 0 - d d - 'Double_t' 0 - e "
"d - 'Double_t' 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TSplinePoly5",1176,G__G__Hist_387_0_3, 105, G__get_linked_tagnum(&G__G__HistLN_TSplinePoly5), -1, 0, 1, 1, 1, 0, "u 'TSplinePoly5' - 41 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Hist_387_0_4, 117, G__get_linked_tagnum(&G__G__HistLN_TSplinePoly5), -1, 1, 1, 1, 1, 0, "u 'TSplinePoly5' - 41 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("B",66,G__G__Hist_387_0_5, 100, -1, G__defined_typename("Double_t"), 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("C",67,G__G__Hist_387_0_6, 100, -1, G__defined_typename("Double_t"), 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("D",68,G__G__Hist_387_0_7, 100, -1, G__defined_typename("Double_t"), 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("E",69,G__G__Hist_387_0_8, 100, -1, G__defined_typename("Double_t"), 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("F",70,G__G__Hist_387_0_9, 100, -1, G__defined_typename("Double_t"), 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Eval",392,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "d - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Derivative",1043,G__G__Hist_387_0_11, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "d - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CopyPoly",831,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'TSplinePoly5' - 41 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Hist_387_0_13, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TSplinePoly5::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_387_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSplinePoly5::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_387_0_15, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TSplinePoly5::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_387_0_16, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TSplinePoly5::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_387_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_387_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSplinePoly5::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_387_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSplinePoly5::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_387_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSplinePoly5::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_387_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSplinePoly5::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TSplinePoly5", 1302, G__G__Hist_387_0_25, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTSpline3(void) {
   /* TSpline3 */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TSpline3));
   G__memfunc_setup("BuildCoeff",979,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetCond",688,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "C - - 10 - opt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TSpline3",754,G__G__Hist_388_0_3, 105, G__get_linked_tagnum(&G__G__HistLN_TSpline3), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TSpline3",754,G__G__Hist_388_0_4, 105, G__get_linked_tagnum(&G__G__HistLN_TSpline3), -1, 0, 7, 1, 1, 0, 
"C - - 10 - title D - 'Double_t' 0 - x "
"D - 'Double_t' 0 - y i - 'Int_t' 0 - n "
"C - - 10 '0' opt d - 'Double_t' 0 '0' valbeg "
"d - 'Double_t' 0 '0' valend", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TSpline3",754,G__G__Hist_388_0_5, 105, G__get_linked_tagnum(&G__G__HistLN_TSpline3), -1, 0, 8, 1, 1, 0, 
"C - - 10 - title d - 'Double_t' 0 - xmin "
"d - 'Double_t' 0 - xmax D - 'Double_t' 0 - y "
"i - 'Int_t' 0 - n C - - 10 '0' opt "
"d - 'Double_t' 0 '0' valbeg d - 'Double_t' 0 '0' valend", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TSpline3",754,G__G__Hist_388_0_6, 105, G__get_linked_tagnum(&G__G__HistLN_TSpline3), -1, 0, 7, 1, 1, 0, 
"C - - 10 - title D - 'Double_t' 0 - x "
"U 'TF1' - 10 - func i - 'Int_t' 0 - n "
"C - - 10 '0' opt d - 'Double_t' 0 '0' valbeg "
"d - 'Double_t' 0 '0' valend", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TSpline3",754,G__G__Hist_388_0_7, 105, G__get_linked_tagnum(&G__G__HistLN_TSpline3), -1, 0, 8, 1, 1, 0, 
"C - - 10 - title d - 'Double_t' 0 - xmin "
"d - 'Double_t' 0 - xmax U 'TF1' - 10 - func "
"i - 'Int_t' 0 - n C - - 10 '0' opt "
"d - 'Double_t' 0 '0' valbeg d - 'Double_t' 0 '0' valend", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TSpline3",754,G__G__Hist_388_0_8, 105, G__get_linked_tagnum(&G__G__HistLN_TSpline3), -1, 0, 5, 1, 1, 0, 
"C - - 10 - title U 'TGraph' - 10 - g "
"C - - 10 '0' opt d - 'Double_t' 0 '0' valbeg "
"d - 'Double_t' 0 '0' valend", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TSpline3",754,G__G__Hist_388_0_9, 105, G__get_linked_tagnum(&G__G__HistLN_TSpline3), -1, 0, 4, 1, 1, 0, 
"U 'TH1' - 10 - h C - - 10 '0' opt "
"d - 'Double_t' 0 '0' valbeg d - 'Double_t' 0 '0' valend", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TSpline3",754,G__G__Hist_388_0_10, 105, G__get_linked_tagnum(&G__G__HistLN_TSpline3), -1, 0, 1, 1, 1, 0, "u 'TSpline3' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Hist_388_0_11, 117, G__get_linked_tagnum(&G__G__HistLN_TSpline3), -1, 1, 1, 1, 1, 0, "u 'TSpline3' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindX",473,G__G__Hist_388_0_12, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "d - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Eval",392,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "d - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Derivative",1043,G__G__Hist_388_0_14, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "d - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCoeff",771,G__G__Hist_388_0_15, 121, -1, -1, 0, 6, 1, 1, 0, 
"i - 'Int_t' 0 - i d - 'Double_t' 1 - x "
"d - 'Double_t' 1 - y d - 'Double_t' 1 - b "
"d - 'Double_t' 1 - c d - 'Double_t' 1 - d", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetKnot",700,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - i d - 'Double_t' 1 - x "
"d - 'Double_t' 1 - y", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SaveAs",579,G__G__Hist_388_0_17, 121, -1, -1, 0, 2, 1, 1, 8, 
"C - - 10 - filename C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPoint",822,G__G__Hist_388_0_19, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - i d - 'Double_t' 0 - x "
"d - 'Double_t' 0 - y", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPointCoeff",1305,G__G__Hist_388_0_20, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - i d - 'Double_t' 0 - b "
"d - 'Double_t' 0 - c d - 'Double_t' 0 - d", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Test",416,G__G__Hist_388_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TSpline3::Test) ), 0);
   G__memfunc_setup("Class",502,G__G__Hist_388_0_22, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TSpline3::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_388_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSpline3::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_388_0_24, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TSpline3::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_388_0_25, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TSpline3::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_388_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_388_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSpline3::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_388_0_31, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSpline3::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_388_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSpline3::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_388_0_33, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSpline3::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TSpline3", 880, G__G__Hist_388_0_34, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTSpline5(void) {
   /* TSpline5 */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TSpline5));
   G__memfunc_setup("BuildCoeff",979,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("BoundaryConditions",1886,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 7, 1, 2, 0, 
"C - - 10 - opt i - 'Int_t' 1 - beg "
"i - 'Int_t' 1 - end C - - 11 - cb1 "
"C - - 11 - ce1 C - - 11 - cb2 "
"C - - 11 - ce2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBoundaries",1336,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 8, 1, 2, 0, 
"d - 'Double_t' 0 - b1 d - 'Double_t' 0 - e1 "
"d - 'Double_t' 0 - b2 d - 'Double_t' 0 - e2 "
"C - - 10 - cb1 C - - 10 - ce1 "
"C - - 10 - cb2 C - - 10 - ce2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TSpline5",756,G__G__Hist_389_0_4, 105, G__get_linked_tagnum(&G__G__HistLN_TSpline5), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TSpline5",756,G__G__Hist_389_0_5, 105, G__get_linked_tagnum(&G__G__HistLN_TSpline5), -1, 0, 9, 1, 1, 0, 
"C - - 10 - title D - 'Double_t' 0 - x "
"D - 'Double_t' 0 - y i - 'Int_t' 0 - n "
"C - - 10 '0' opt d - 'Double_t' 0 '0' b1 "
"d - 'Double_t' 0 '0' e1 d - 'Double_t' 0 '0' b2 "
"d - 'Double_t' 0 '0' e2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TSpline5",756,G__G__Hist_389_0_6, 105, G__get_linked_tagnum(&G__G__HistLN_TSpline5), -1, 0, 10, 1, 1, 0, 
"C - - 10 - title d - 'Double_t' 0 - xmin "
"d - 'Double_t' 0 - xmax D - 'Double_t' 0 - y "
"i - 'Int_t' 0 - n C - - 10 '0' opt "
"d - 'Double_t' 0 '0' b1 d - 'Double_t' 0 '0' e1 "
"d - 'Double_t' 0 '0' b2 d - 'Double_t' 0 '0' e2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TSpline5",756,G__G__Hist_389_0_7, 105, G__get_linked_tagnum(&G__G__HistLN_TSpline5), -1, 0, 9, 1, 1, 0, 
"C - - 10 - title D - 'Double_t' 0 - x "
"U 'TF1' - 10 - func i - 'Int_t' 0 - n "
"C - - 10 '0' opt d - 'Double_t' 0 '0' b1 "
"d - 'Double_t' 0 '0' e1 d - 'Double_t' 0 '0' b2 "
"d - 'Double_t' 0 '0' e2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TSpline5",756,G__G__Hist_389_0_8, 105, G__get_linked_tagnum(&G__G__HistLN_TSpline5), -1, 0, 10, 1, 1, 0, 
"C - - 10 - title d - 'Double_t' 0 - xmin "
"d - 'Double_t' 0 - xmax U 'TF1' - 10 - func "
"i - 'Int_t' 0 - n C - - 10 '0' opt "
"d - 'Double_t' 0 '0' b1 d - 'Double_t' 0 '0' e1 "
"d - 'Double_t' 0 '0' b2 d - 'Double_t' 0 '0' e2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TSpline5",756,G__G__Hist_389_0_9, 105, G__get_linked_tagnum(&G__G__HistLN_TSpline5), -1, 0, 7, 1, 1, 0, 
"C - - 10 - title U 'TGraph' - 10 - g "
"C - - 10 '0' opt d - 'Double_t' 0 '0' b1 "
"d - 'Double_t' 0 '0' e1 d - 'Double_t' 0 '0' b2 "
"d - 'Double_t' 0 '0' e2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TSpline5",756,G__G__Hist_389_0_10, 105, G__get_linked_tagnum(&G__G__HistLN_TSpline5), -1, 0, 6, 1, 1, 0, 
"U 'TH1' - 10 - h C - - 10 '0' opt "
"d - 'Double_t' 0 '0' b1 d - 'Double_t' 0 '0' e1 "
"d - 'Double_t' 0 '0' b2 d - 'Double_t' 0 '0' e2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TSpline5",756,G__G__Hist_389_0_11, 105, G__get_linked_tagnum(&G__G__HistLN_TSpline5), -1, 0, 1, 1, 1, 0, "u 'TSpline5' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Hist_389_0_12, 117, G__get_linked_tagnum(&G__G__HistLN_TSpline5), -1, 1, 1, 1, 1, 0, "u 'TSpline5' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindX",473,G__G__Hist_389_0_13, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "d - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Eval",392,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "d - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Derivative",1043,G__G__Hist_389_0_15, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "d - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCoeff",771,G__G__Hist_389_0_16, 121, -1, -1, 0, 8, 1, 1, 0, 
"i - 'Int_t' 0 - i d - 'Double_t' 1 - x "
"d - 'Double_t' 1 - y d - 'Double_t' 1 - b "
"d - 'Double_t' 1 - c d - 'Double_t' 1 - d "
"d - 'Double_t' 1 - e d - 'Double_t' 1 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetKnot",700,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - i d - 'Double_t' 1 - x "
"d - 'Double_t' 1 - y", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SaveAs",579,G__G__Hist_389_0_18, 121, -1, -1, 0, 2, 1, 1, 8, 
"C - - 10 - filename C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPoint",822,G__G__Hist_389_0_20, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - i d - 'Double_t' 0 - x "
"d - 'Double_t' 0 - y", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPointCoeff",1305,G__G__Hist_389_0_21, 121, -1, -1, 0, 6, 1, 1, 0, 
"i - 'Int_t' 0 - i d - 'Double_t' 0 - b "
"d - 'Double_t' 0 - c d - 'Double_t' 0 - d "
"d - 'Double_t' 0 - e d - 'Double_t' 0 - f", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Test",416,G__G__Hist_389_0_22, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TSpline5::Test) ), 0);
   G__memfunc_setup("Class",502,G__G__Hist_389_0_23, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TSpline5::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_389_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSpline5::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_389_0_25, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TSpline5::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_389_0_26, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TSpline5::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_389_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_389_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSpline5::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_389_0_32, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSpline5::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_389_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSpline5::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_389_0_34, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSpline5::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TSpline5", 882, G__G__Hist_389_0_35, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTSVDUnfold(void) {
   /* TSVDUnfold */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TSVDUnfold));
   G__memfunc_setup("TSVDUnfold",937,G__G__Hist_390_0_1, 105, G__get_linked_tagnum(&G__G__HistLN_TSVDUnfold), -1, 0, 4, 1, 1, 0, 
"U 'TH1D' - 10 - bdat U 'TH1D' - 10 - bini "
"U 'TH1D' - 10 - xini U 'TH2D' - 10 - Adet", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TSVDUnfold",937,G__G__Hist_390_0_2, 105, G__get_linked_tagnum(&G__G__HistLN_TSVDUnfold), -1, 0, 1, 1, 1, 0, "u 'TSVDUnfold' - 11 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNormalize",1245,G__G__Hist_390_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - normalize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Unfold",616,G__G__Hist_390_0_4, 85, G__get_linked_tagnum(&G__G__HistLN_TH1D), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - kreg", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetUnfoldCovMatrix",1829,G__G__Hist_390_0_5, 85, G__get_linked_tagnum(&G__G__HistLN_TH2D), -1, 0, 3, 1, 1, 0, 
"U 'TH2D' - 10 - cov i - 'Int_t' 0 - ntoys "
"i - 'Int_t' 0 '1' seed", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAdetCovMatrix",1595,G__G__Hist_390_0_6, 85, G__get_linked_tagnum(&G__G__HistLN_TH2D), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - ntoys i - 'Int_t' 0 '1' seed", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetKReg",649,G__G__Hist_390_0_7, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetD",356,G__G__Hist_390_0_8, 85, G__get_linked_tagnum(&G__G__HistLN_TH1D), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSV",457,G__G__Hist_390_0_9, 85, G__get_linked_tagnum(&G__G__HistLN_TH1D), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ComputeChiSquared",1734,G__G__Hist_390_0_10, 100, -1, G__defined_typename("Double_t"), 0, 4, 3, 1, 0, 
"u 'TH1D' - 11 - truspec u 'TH1D' - 11 - unfspec "
"u 'TH2D' - 11 - covmat d - 'Double_t' 0 '0.01' regpar", (char*)NULL, (void*) G__func2void( (Double_t (*)(const TH1D&, const TH1D&, const TH2D&, Double_t))(&TSVDUnfold::ComputeChiSquared) ), 0);
   G__memfunc_setup("FillCurvatureMatrix",1981,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 8, 
"u 'TMatrixT<double>' 'TMatrixD' 1 - tCurv u 'TMatrixT<double>' 'TMatrixD' 1 - tC", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCurvature",1249,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 2, 3, 4, 0, 
"u 'TVectorT<double>' 'TVectorD' 11 - vec u 'TMatrixT<double>' 'TMatrixD' 11 - curv", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InitHistos",1038,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("H2V",208,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 3, 4, 0, 
"U 'TH1D' - 10 - histo u 'TVectorT<double>' 'TVectorD' 1 - vec", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("H2Verr",537,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 3, 4, 0, 
"U 'TH1D' - 10 - histo u 'TVectorT<double>' 'TVectorD' 1 - vec", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("V2H",208,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 3, 4, 0, 
"u 'TVectorT<double>' 'TVectorD' 11 - vec u 'TH1D' - 1 - histo", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("H2M",199,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 3, 4, 0, 
"U 'TH2D' - 10 - histo u 'TMatrixT<double>' 'TMatrixD' 1 - mat", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MatDivVec",867,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__HistLN_TMatrixTlEdoublegR), G__defined_typename("TMatrixD"), 0, 3, 3, 4, 0, 
"u 'TMatrixT<double>' 'TMatrixD' 11 - mat u 'TVectorT<double>' 'TVectorD' 11 - vec "
"i - 'Int_t' 0 '0' zero", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CompProd",804,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__HistLN_TVectorTlEdoublegR), G__defined_typename("TVectorD"), 0, 2, 3, 4, 0, 
"u 'TVectorT<double>' 'TVectorD' 11 - vec1 u 'TVectorT<double>' 'TVectorD' 11 - vec2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("VecDiv",577,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__HistLN_TVectorTlEdoublegR), G__defined_typename("TVectorD"), 0, 3, 3, 4, 0, 
"u 'TVectorT<double>' 'TVectorD' 11 - vec1 u 'TVectorT<double>' 'TVectorD' 11 - vec2 "
"i - 'Int_t' 0 '0' zero", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RegularisedSymMatInvert",2378,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 3, 4, 0, 
"u 'TMatrixTSym<double>' 'TMatrixDSym' 1 - mat d - 'Double_t' 0 '1e-3' eps", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Hist_390_0_22, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TSVDUnfold::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_390_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSVDUnfold::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_390_0_24, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TSVDUnfold::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_390_0_25, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TSVDUnfold::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_390_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_390_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSVDUnfold::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_390_0_31, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSVDUnfold::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_390_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSVDUnfold::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_390_0_33, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSVDUnfold::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TSVDUnfold", 1063, G__G__Hist_390_0_34, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTUnfold(void) {
   /* TUnfold */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TUnfold));
   G__memfunc_setup("InitTUnfold",1104,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", "initialize all data members", (void*) NULL, 0);
   G__memfunc_setup("TUnfold",700,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__HistLN_TUnfold), -1, 0, 0, 1, 2, 0, "", "for derived classes", (void*) NULL, 0);
   G__memfunc_setup("DoUnfold",795,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 2, 0, "", "the unfolding algorithm", (void*) NULL, 1);
   G__memfunc_setup("ClearResults",1241,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", "clear all results", (void*) NULL, 1);
   G__memfunc_setup("MultiplyMSparseM",1640,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__HistLN_TMatrixTSparselEdoublegR), G__defined_typename("TMatrixDSparse"), 0, 2, 1, 2, 8, 
"U 'TMatrixTSparse<double>' 'TMatrixDSparse' 10 - a U 'TMatrixT<double>' 'TMatrixD' 10 - b", "multiply sparse and non-sparse matrix", (void*) NULL, 0);
   G__memfunc_setup("MultiplyMSparseMSparse",2262,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__HistLN_TMatrixTSparselEdoublegR), G__defined_typename("TMatrixDSparse"), 0, 2, 1, 2, 8, 
"U 'TMatrixTSparse<double>' 'TMatrixDSparse' 10 - a U 'TMatrixTSparse<double>' 'TMatrixDSparse' 10 - b", "multiply sparse and sparse matrix", (void*) NULL, 0);
   G__memfunc_setup("MultiplyMSparseTranspMSparse",2894,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__HistLN_TMatrixTSparselEdoublegR), G__defined_typename("TMatrixDSparse"), 0, 2, 1, 2, 8, 
"U 'TMatrixTSparse<double>' 'TMatrixDSparse' 10 - a U 'TMatrixTSparse<double>' 'TMatrixDSparse' 10 - b", "multiply transposed sparse and sparse matrix", (void*) NULL, 0);
   G__memfunc_setup("MultiplyMSparseMSparseTranspVector",3521,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__HistLN_TMatrixTSparselEdoublegR), G__defined_typename("TMatrixDSparse"), 0, 3, 1, 2, 8, 
"U 'TMatrixTSparse<double>' 'TMatrixDSparse' 10 - m1 U 'TMatrixTSparse<double>' 'TMatrixDSparse' 10 - m2 "
"U 'TMatrixTBase<double>' 'TMatrixTBase<Double_t>' 10 - v", "calculate M_ij = sum_k [m1_ik*m2_jk*v[k] ]. the pointer v may be zero (means no scaling).", (void*) NULL, 0);
   G__memfunc_setup("InvertMSparse",1331,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__HistLN_TMatrixTlEdoublegR), G__defined_typename("TMatrixD"), 0, 1, 1, 2, 8, "U 'TMatrixTSparse<double>' 'TMatrixDSparse' 10 - A", "invert sparse matrix", (void*) NULL, 0);
   G__memfunc_setup("InvertMConditioned",1845,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 3, 2, 0, "U 'TMatrixT<double>' 'TMatrixD' 0 - A", "invert matrix including preconditioning", (void*) NULL, 0);
   G__memfunc_setup("AddMSparse",964,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"U 'TMatrixTSparse<double>' 'TMatrixDSparse' 0 - dest d - 'Double_t' 0 - f "
"U 'TMatrixTSparse<double>' 'TMatrixDSparse' 10 - src", "replacement for dest += f*src", (void*) NULL, 0);
   G__memfunc_setup("CreateSparseMatrix",1847,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__HistLN_TMatrixTSparselEdoublegR), G__defined_typename("TMatrixDSparse"), 0, 6, 1, 2, 8, 
"i - 'Int_t' 0 - nrow i - 'Int_t' 0 - ncol "
"i - 'Int_t' 0 - nele I - 'Int_t' 0 - row "
"I - 'Int_t' 0 - col D - 'Double_t' 0 - data", "create a TMatrixDSparse from an array", (void*) NULL, 0);
   G__memfunc_setup("GetNx",486,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 2, 8, "", "number of non-zero output bins", (void*) NULL, 0);
   G__memfunc_setup("GetNy",487,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 2, 8, "", "number of input bins", (void*) NULL, 0);
   G__memfunc_setup("ErrorMatrixToHist",1754,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 2, 8, 
"U 'TH2' - 0 - ematrix U 'TMatrixTSparse<double>' 'TMatrixDSparse' 10 - emat "
"I - 'Int_t' 10 - binMap g - 'Bool_t' 0 - doClear", "return an error matrix as histogram", (void*) NULL, 0);
   G__memfunc_setup("GetDXDY",601,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__HistLN_TMatrixTSparselEdoublegR), G__defined_typename("TMatrixDSparse"), 0, 0, 1, 2, 9, "", "access derivative dx/dy", (void*) NULL, 0);
   G__memfunc_setup("GetDXDAM",654,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__HistLN_TMatrixTSparselEdoublegR), G__defined_typename("TMatrixDSparse"), 0, 1, 1, 2, 9, "i - - 0 - i", "access matrix parts of the derivative dx/dA", (void*) NULL, 0);
   G__memfunc_setup("GetDXDAZ",667,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__HistLN_TMatrixTSparselEdoublegR), G__defined_typename("TMatrixDSparse"), 0, 1, 1, 2, 9, "i - - 0 - i", "access vector parts of the derivative dx/dA", (void*) NULL, 0);
   G__memfunc_setup("GetDXDtauSquared",1567,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__HistLN_TMatrixTSparselEdoublegR), G__defined_typename("TMatrixDSparse"), 0, 0, 1, 2, 9, "", "get derivative dx/dtauSquared", (void*) NULL, 0);
   G__memfunc_setup("GetAx",473,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__HistLN_TMatrixTSparselEdoublegR), G__defined_typename("TMatrixDSparse"), 0, 0, 1, 2, 9, "", "get vector Ax", (void*) NULL, 0);
   G__memfunc_setup("GetEinv",690,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__HistLN_TMatrixTSparselEdoublegR), G__defined_typename("TMatrixDSparse"), 0, 0, 1, 2, 9, "", "get matrix E^-1", (void*) NULL, 0);
   G__memfunc_setup("GetE",357,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__HistLN_TMatrixTSparselEdoublegR), G__defined_typename("TMatrixDSparse"), 0, 0, 1, 2, 9, "", "get matrix E", (void*) NULL, 0);
   G__memfunc_setup("GetVxx",614,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__HistLN_TMatrixTSparselEdoublegR), G__defined_typename("TMatrixDSparse"), 0, 0, 1, 2, 9, "", "get covariance matrix of x", (void*) NULL, 0);
   G__memfunc_setup("GetVxxInv",915,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__HistLN_TMatrixTSparselEdoublegR), G__defined_typename("TMatrixDSparse"), 0, 0, 1, 2, 9, "", "get inverse of covariance matrix of x", (void*) NULL, 0);
   G__memfunc_setup("GetX",376,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__HistLN_TMatrixTlEdoublegR), G__defined_typename("TMatrixD"), 0, 0, 1, 2, 9, "", "get result vector x", (void*) NULL, 0);
   G__memfunc_setup("DeleteMatrix",1224,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 3, 2, 0, "U 'TMatrixT<double>' 'TMatrixD' 2 - m", "delete and invalidate pointer", (void*) NULL, 0);
   G__memfunc_setup("DeleteMatrix",1224,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 3, 2, 0, "U 'TMatrixTSparse<double>' 'TMatrixDSparse' 2 - m", "delete and invalidate pointer", (void*) NULL, 0);
   G__memfunc_setup("TUnfold",700,G__G__Hist_391_0_28, 105, G__get_linked_tagnum(&G__G__HistLN_TUnfold), -1, 0, 4, 1, 1, 0, 
"U 'TH2' - 10 - hist_A i 'TUnfold::EHistMap' - 0 - histmap "
"i 'TUnfold::ERegMode' - 0 'kRegModeSize' regmode i 'TUnfold::EConstraint' - 0 'kEConstraintArea' constraint", "constructor", (void*) NULL, 0);
   G__memfunc_setup("GetTUnfoldVersion",1730,G__G__Hist_391_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TUnfold::GetTUnfoldVersion) ), 0);
   G__memfunc_setup("SetBias",683,G__G__Hist_391_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TH1' - 10 - bias", "set alternative bias", (void*) NULL, 0);
   G__memfunc_setup("SetConstraint",1361,G__G__Hist_391_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TUnfold::EConstraint' - 0 - constraint", "set type of constraint for the next unfolding", (void*) NULL, 0);
   G__memfunc_setup("RegularizeSize",1461,G__G__Hist_391_0_32, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - - 0 - bin d - 'Double_t' 0 '1.0' scale", "regularise the size of one output bin", (void*) NULL, 0);
   G__memfunc_setup("RegularizeDerivative",2093,G__G__Hist_391_0_33, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"i - - 0 - left_bin i - - 0 - right_bin "
"d - 'Double_t' 0 '1.0' scale", "regularize difference of two output bins (1st derivative)", (void*) NULL, 0);
   G__memfunc_setup("RegularizeCurvature",2011,G__G__Hist_391_0_34, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 0, 
"i - - 0 - left_bin i - - 0 - center_bin "
"i - - 0 - right_bin d - 'Double_t' 0 '1.0' scale_left "
"d - 'Double_t' 0 '1.0' scale_right", "regularize curvature of three output bins (2nd derivative)", (void*) NULL, 0);
   G__memfunc_setup("RegularizeBins",1446,G__G__Hist_391_0_35, 105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
"i - - 0 - start i - - 0 - step "
"i - - 0 - nbin i 'TUnfold::ERegMode' - 0 - regmode", "regularize a 1-dimensional curve", (void*) NULL, 0);
   G__memfunc_setup("RegularizeBins2D",1564,G__G__Hist_391_0_36, 105, -1, G__defined_typename("Int_t"), 0, 6, 1, 1, 0, 
"i - - 0 - start_bin i - - 0 - step1 "
"i - - 0 - nbin1 i - - 0 - step2 "
"i - - 0 - nbin2 i 'TUnfold::ERegMode' - 0 - regmode", "regularize a 2-dimensional grid", (void*) NULL, 0);
   G__memfunc_setup("DoUnfold",795,G__G__Hist_391_0_37, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - tau U 'TH1' - 10 - hist_y "
"d - 'Double_t' 0 '0.0' scaleBias", "do the unfolding", (void*) NULL, 0);
   G__memfunc_setup("SetInput",828,G__G__Hist_391_0_38, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"U 'TH1' - 10 - hist_y d - 'Double_t' 0 '0.0' scaleBias "
"d - 'Double_t' 0 '0.0' oneOverZeroError", "define input distribution for ScanLCurve", (void*) NULL, 1);
   G__memfunc_setup("DoUnfold",795,G__G__Hist_391_0_39, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - tau", "Unfold with given choice of tau", (void*) NULL, 1);
   G__memfunc_setup("ScanLcurve",1014,G__G__Hist_391_0_40, 105, -1, G__defined_typename("Int_t"), 0, 6, 1, 1, 0, 
"i - 'Int_t' 0 - nPoint d - 'Double_t' 0 - tauMin "
"d - 'Double_t' 0 - tauMax U 'TGraph' - 2 - lCurve "
"U 'TSpline' - 2 '0' logTauX U 'TSpline' - 2 '0' logTauY", "scan the L curve using successive calls to DoUnfold(Double_t)", (void*) NULL, 1);
   G__memfunc_setup("GetOutput",945,G__G__Hist_391_0_41, 85, G__get_linked_tagnum(&G__G__HistLN_TH1D), -1, 0, 4, 1, 1, 8, 
"C - - 10 - name C - - 10 - title "
"d - 'Double_t' 0 '0.0' x0 d - 'Double_t' 0 '0.0' x1", "get unfolding result", (void*) NULL, 0);
   G__memfunc_setup("GetBias",671,G__G__Hist_391_0_42, 85, G__get_linked_tagnum(&G__G__HistLN_TH1D), -1, 0, 4, 1, 1, 8, 
"C - - 10 - name C - - 10 - title "
"d - 'Double_t' 0 '0.0' x0 d - 'Double_t' 0 '0.0' x1", "get bias", (void*) NULL, 0);
   G__memfunc_setup("GetFoldedOutput",1535,G__G__Hist_391_0_43, 85, G__get_linked_tagnum(&G__G__HistLN_TH1D), -1, 0, 4, 1, 1, 8, 
"C - - 10 - name C - - 10 - title "
"d - 'Double_t' 0 '0.0' y0 d - 'Double_t' 0 '0.0' y1", "get folded unfolding result", (void*) NULL, 0);
   G__memfunc_setup("GetInput",816,G__G__Hist_391_0_44, 85, G__get_linked_tagnum(&G__G__HistLN_TH1D), -1, 0, 4, 1, 1, 8, 
"C - - 10 - name C - - 10 - title "
"d - 'Double_t' 0 '0.0' y0 d - 'Double_t' 0 '0.0' y1", "get unfolding input", (void*) NULL, 0);
   G__memfunc_setup("GetRhoIJ",732,G__G__Hist_391_0_45, 85, G__get_linked_tagnum(&G__G__HistLN_TH2D), -1, 0, 4, 1, 1, 8, 
"C - - 10 - name C - - 10 - title "
"d - 'Double_t' 0 '0.0' x0 d - 'Double_t' 0 '0.0' x1", "get correlation coefficients", (void*) NULL, 0);
   G__memfunc_setup("GetEmatrix",1018,G__G__Hist_391_0_46, 85, G__get_linked_tagnum(&G__G__HistLN_TH2D), -1, 0, 4, 1, 1, 8, 
"C - - 10 - name C - - 10 - title "
"d - 'Double_t' 0 '0.0' x0 d - 'Double_t' 0 '0.0' x1", "get error matrix", (void*) NULL, 0);
   G__memfunc_setup("GetRhoI",658,G__G__Hist_391_0_47, 85, G__get_linked_tagnum(&G__G__HistLN_TH1D), -1, 0, 4, 1, 1, 8, 
"C - - 10 - name C - - 10 - title "
"d - 'Double_t' 0 '0.0' x0 d - 'Double_t' 0 '0.0' x1", "get global correlation coefficients", (void*) NULL, 0);
   G__memfunc_setup("GetLsquared",1121,G__G__Hist_391_0_48, 85, G__get_linked_tagnum(&G__G__HistLN_TH2D), -1, 0, 4, 1, 1, 8, 
"C - - 10 - name C - - 10 - title "
"d - 'Double_t' 0 '0.0' x0 d - 'Double_t' 0 '0.0' x1", "get regularisation conditions squared", (void*) NULL, 0);
   G__memfunc_setup("GetOutput",945,G__G__Hist_391_0_49, 121, -1, -1, 0, 2, 1, 1, 8, 
"U 'TH1' - 0 - output I - 'Int_t' 10 '0' binMap", "get output distribution, averaged over bins", (void*) NULL, 0);
   G__memfunc_setup("GetEmatrix",1018,G__G__Hist_391_0_50, 121, -1, -1, 0, 2, 1, 1, 8, 
"U 'TH2' - 0 - ematrix I - 'Int_t' 10 '0' binMap", "get error matrix, averaged over bins", (void*) NULL, 0);
   G__memfunc_setup("GetRhoI",658,G__G__Hist_391_0_51, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"U 'TH1' - 0 - rhoi U 'TH2' - 0 '0' ematrixinv "
"I - 'Int_t' 10 '0' binMap", "get global correlation coefficients and inverse of error matrix, averaged over bins", (void*) NULL, 0);
   G__memfunc_setup("GetRhoIJ",732,G__G__Hist_391_0_52, 121, -1, -1, 0, 2, 1, 1, 8, 
"U 'TH2' - 0 - rhoij I - 'Int_t' 10 '0' binMap", "get correlation coefficients, averaged over bins", (void*) NULL, 0);
   G__memfunc_setup("GetTau",586,G__G__Hist_391_0_53, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", "regularisation parameter", (void*) NULL, 0);
   G__memfunc_setup("GetRhoMax",879,G__G__Hist_391_0_54, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", "maximum global correlation", (void*) NULL, 0);
   G__memfunc_setup("GetRhoAvg",871,G__G__Hist_391_0_55, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", "average global correlation", (void*) NULL, 0);
   G__memfunc_setup("GetChi2A",679,G__G__Hist_391_0_56, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", "chi**2 contribution from A", (void*) NULL, 0);
   G__memfunc_setup("GetChi2L",690,G__G__Hist_391_0_57, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", "chi**2 contribution from L", (void*) NULL, 0);
   G__memfunc_setup("GetLcurveX",1001,G__G__Hist_391_0_58, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", "x axis of L curve", (void*) NULL, 1);
   G__memfunc_setup("GetLcurveY",1002,G__G__Hist_391_0_59, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", "y axis of L curve", (void*) NULL, 1);
   G__memfunc_setup("GetNdf",568,G__G__Hist_391_0_60, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", "number of degrees of freedom", (void*) NULL, 0);
   G__memfunc_setup("GetNpar",689,G__G__Hist_391_0_61, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", "number of parameters", (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Hist_391_0_62, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TUnfold::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_391_0_63, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TUnfold::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_391_0_64, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TUnfold::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_391_0_65, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TUnfold::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_391_0_69, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_391_0_70, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TUnfold::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_391_0_71, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TUnfold::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_391_0_72, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TUnfold::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_391_0_73, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TUnfold::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TUnfold", 700, G__G__Hist_391_0_74, (int) ('i'), G__get_linked_tagnum(&G__G__HistLN_TUnfold), -1, 0, 1, 1, 1, 0, "u 'TUnfold' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TUnfold", 826, G__G__Hist_391_0_75, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Hist_391_0_76, (int) ('u'), G__get_linked_tagnum(&G__G__HistLN_TUnfold), -1, 1, 1, 1, 1, 0, "u 'TUnfold' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTUnfoldSys(void) {
   /* TUnfoldSys */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TUnfoldSys));
   G__memfunc_setup("InitTUnfoldSys",1423,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", "initialize all data members", (void*) NULL, 0);
   G__memfunc_setup("TUnfoldSys",1019,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__HistLN_TUnfoldSys), -1, 0, 0, 1, 2, 0, "", "for derived classes", (void*) NULL, 0);
   G__memfunc_setup("ClearResults",1241,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", "clear all results", (void*) NULL, 1);
   G__memfunc_setup("PrepareSysError",1560,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", "common calculations for syst.errors", (void*) NULL, 1);
   G__memfunc_setup("PrepareUncorrEmat",1743,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__HistLN_TMatrixTSparselEdoublegR), G__defined_typename("TMatrixDSparse"), 0, 2, 1, 2, 0, 
"U 'TMatrixTSparse<double>' 'TMatrixDSparse' 10 - m1 U 'TMatrixTSparse<double>' 'TMatrixDSparse' 10 - m2", "calculate uncorrelated error matrix", (void*) NULL, 1);
   G__memfunc_setup("PrepareCorrEmat",1516,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__HistLN_TMatrixTSparselEdoublegR), G__defined_typename("TMatrixDSparse"), 0, 3, 1, 2, 0, 
"U 'TMatrixTSparse<double>' 'TMatrixDSparse' 10 - m1 U 'TMatrixTSparse<double>' 'TMatrixDSparse' 10 - m2 "
"U 'TMatrixTSparse<double>' 'TMatrixDSparse' 10 - dsys", "calculate correlated error matrix", (void*) NULL, 1);
   G__memfunc_setup("ScaleColumnsByVector",2039,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 8, 
"U 'TMatrixTSparse<double>' 'TMatrixDSparse' 0 - m U 'TMatrixTBase<double>' 'TMatrixTBase<Double_t>' 10 - v", "scale columns of m by the corresponding rows of v", (void*) NULL, 0);
   G__memfunc_setup("VectorMapToHist",1516,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"U 'TH1' - 0 - hist_delta U 'TMatrixTSparse<double>' 'TMatrixDSparse' 10 - delta "
"I - 'Int_t' 10 - binMap", "map and sum vector delta, save in hist_delta", (void*) NULL, 0);
   G__memfunc_setup("GetEmatrixFromVyy",1750,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 2, 0, 
"U 'TMatrixTSparse<double>' 'TMatrixDSparse' 10 - vyy U 'TH2' - 0 - ematrix "
"I - 'Int_t' 10 - binMap g - 'Bool_t' 0 - clearEmat", "propagate error matrix vyy to the result", (void*) NULL, 0);
   G__memfunc_setup("DoBackgroundSubtraction",2369,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TUnfoldSys",1019,G__G__Hist_396_0_11, 105, G__get_linked_tagnum(&G__G__HistLN_TUnfoldSys), -1, 0, 4, 1, 1, 0, 
"U 'TH2' - 10 - hist_A i 'TUnfold::EHistMap' - 0 - histmap "
"i 'TUnfold::ERegMode' - 0 'kRegModeSize' regmode i 'TUnfold::EConstraint' - 0 'kEConstraintNone' constraint", "constructor", (void*) NULL, 0);
   G__memfunc_setup("AddSysError",1106,G__G__Hist_396_0_12, 121, -1, -1, 0, 4, 1, 1, 0, 
"U 'TH2' - 10 - sysError C - - 10 - name "
"i 'TUnfold::EHistMap' - 0 - histmap i 'TUnfoldSys::ESysErrMode' - 0 - mode", "add a systematic error source", (void*) NULL, 0);
   G__memfunc_setup("GetDeltaSysSource",1722,G__G__Hist_396_0_13, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TH1' - 0 - hist_delta C - - 10 - source "
"I - 'Int_t' 10 '0' binMap", "get systematic shifts from one systematic source", (void*) NULL, 0);
   G__memfunc_setup("SubtractBackground",1864,G__G__Hist_396_0_14, 121, -1, -1, 0, 4, 1, 1, 0, 
"U 'TH1' - 10 - hist_bgr C - - 10 - name "
"d - 'Double_t' 0 '1.0' scale d - 'Double_t' 0 '0.0' scale_error", "subtract background prior to unfolding", (void*) NULL, 0);
   G__memfunc_setup("SetInput",828,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"U 'TH1' - 10 - hist_y d - 'Double_t' 0 '0.0' scaleBias "
"d - 'Double_t' 0 '0.0' oneOverZeroError", "define input consistently in case of background subtraction", (void*) NULL, 1);
   G__memfunc_setup("GetDeltaSysBackgroundScale",2609,G__G__Hist_396_0_16, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TH1' - 0 - delta C - - 10 - source "
"I - 'Int_t' 10 '0' binMap", "get correlated uncertainty induced by the scale uncertainty of a background source", (void*) NULL, 0);
   G__memfunc_setup("SetTauError",1120,G__G__Hist_396_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - delta_tau", "set uncertainty on tau", (void*) NULL, 0);
   G__memfunc_setup("GetDeltaSysTau",1395,G__G__Hist_396_0_18, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TH1' - 0 - delta I - 'Int_t' 10 '0' binMap", "get correlated uncertainty from varying tau", (void*) NULL, 0);
   G__memfunc_setup("GetEmatrixSysUncorr",1970,G__G__Hist_396_0_19, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TH2' - 0 - ematrix I - 'Int_t' 10 '0' binMap "
"g - 'Bool_t' 0 'kTRUE' clearEmat", "get error matrix contribution from uncorrelated errors on the matrix A", (void*) NULL, 0);
   G__memfunc_setup("GetEmatrixSysSource",1962,G__G__Hist_396_0_20, 121, -1, -1, 0, 4, 1, 1, 0, 
"U 'TH2' - 0 - ematrix C - - 10 - source "
"I - 'Int_t' 10 '0' binMap g - 'Bool_t' 0 'kTRUE' clearEmat", "get error matrix from one systematic source", (void*) NULL, 0);
   G__memfunc_setup("GetEmatrixSysBackgroundUncorr",2994,G__G__Hist_396_0_21, 121, -1, -1, 0, 4, 1, 1, 0, 
"U 'TH2' - 0 - ematrix C - - 10 - source "
"I - 'Int_t' 10 '0' binMap g - 'Bool_t' 0 'kTRUE' clearEmat", "get error matrix from uncorrelated error of one background source", (void*) NULL, 0);
   G__memfunc_setup("GetEmatrixSysBackgroundScale",2849,G__G__Hist_396_0_22, 121, -1, -1, 0, 4, 1, 1, 0, 
"U 'TH2' - 0 - ematrix C - - 10 - source "
"I - 'Int_t' 10 '0' binMap g - 'Bool_t' 0 'kTRUE' clearEmat", "get error matrix from the scale error of one background source", (void*) NULL, 0);
   G__memfunc_setup("GetEmatrixSysTau",1635,G__G__Hist_396_0_23, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TH2' - 0 - ematrix I - 'Int_t' 10 '0' binMap "
"g - 'Bool_t' 0 'kTRUE' clearEmat", "get error matrix from tau variation", (void*) NULL, 0);
   G__memfunc_setup("GetEmatrixInput",1546,G__G__Hist_396_0_24, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TH2' - 0 - ematrix I - 'Int_t' 10 '0' binMap "
"g - 'Bool_t' 0 'kTRUE' clearEmat", "get error contribution from input vector", (void*) NULL, 0);
   G__memfunc_setup("GetEmatrixTotal",1534,G__G__Hist_396_0_25, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TH2' - 0 - ematrix I - 'Int_t' 10 '0' binMap", "get total error including systematic,statistical,background,tau errors", (void*) NULL, 0);
   G__memfunc_setup("GetChi2Sys",933,G__G__Hist_396_0_26, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", "get total chi**2 including all systematic errors", (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Hist_396_0_27, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TUnfoldSys::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_396_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TUnfoldSys::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_396_0_29, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TUnfoldSys::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_396_0_30, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TUnfoldSys::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_396_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_396_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TUnfoldSys::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_396_0_36, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TUnfoldSys::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_396_0_37, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TUnfoldSys::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_396_0_38, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TUnfoldSys::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TUnfoldSys", 1019, G__G__Hist_396_0_39, (int) ('i'), G__get_linked_tagnum(&G__G__HistLN_TUnfoldSys), -1, 0, 1, 1, 1, 0, "u 'TUnfoldSys' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TUnfoldSys", 1145, G__G__Hist_396_0_40, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Hist_396_0_41, (int) ('u'), G__get_linked_tagnum(&G__G__HistLN_TUnfoldSys), -1, 1, 1, 1, 1, 0, "u 'TUnfoldSys' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTVirtualGraphPainter(void) {
   /* TVirtualGraphPainter */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_TVirtualGraphPainter));
   G__memfunc_setup("DistancetoPrimitiveHelper",2599,G__G__Hist_398_0_2, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"U 'TGraph' - 0 - theGraph i - 'Int_t' 0 - px "
"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("DrawPanelHelper",1502,G__G__Hist_398_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGraph' - 0 - theGraph", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ExecuteEventHelper",1845,G__G__Hist_398_0_4, 121, -1, -1, 0, 4, 1, 1, 0, 
"U 'TGraph' - 0 - theGraph i - 'Int_t' 0 - event "
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetObjectInfoHelper",1891,G__G__Hist_398_0_5, 67, -1, -1, 0, 3, 1, 1, 8, 
"U 'TGraph' - 0 - theGraph i - 'Int_t' 0 - px "
"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("PaintHelper",1116,G__G__Hist_398_0_6, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGraph' - 0 - theGraph C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("PaintGraph",1006,G__G__Hist_398_0_7, 121, -1, -1, 0, 5, 1, 1, 0, 
"U 'TGraph' - 0 - theGraph i - 'Int_t' 0 - npoints "
"D - 'Double_t' 10 - x D - 'Double_t' 10 - y "
"C - 'Option_t' 10 - chopt", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("PaintGrapHist",1310,G__G__Hist_398_0_8, 121, -1, -1, 0, 5, 1, 1, 0, 
"U 'TGraph' - 0 - theGraph i - 'Int_t' 0 - npoints "
"D - 'Double_t' 10 - x D - 'Double_t' 10 - y "
"C - 'Option_t' 10 - chopt", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("PaintStats",1035,G__G__Hist_398_0_9, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGraph' - 0 - theGraph U 'TF1' - 0 - fit", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetPainter",1011,G__G__Hist_398_0_10, 85, G__get_linked_tagnum(&G__G__HistLN_TVirtualGraphPainter), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TVirtualGraphPainter* (*)())(&TVirtualGraphPainter::GetPainter) ), 0);
   G__memfunc_setup("SetPainter",1023,G__G__Hist_398_0_11, 121, -1, -1, 0, 1, 3, 1, 0, "U 'TVirtualGraphPainter' - 0 - painter", (char*)NULL, (void*) G__func2void( (void (*)(TVirtualGraphPainter*))(&TVirtualGraphPainter::SetPainter) ), 0);
   G__memfunc_setup("Class",502,G__G__Hist_398_0_12, 85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TVirtualGraphPainter::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Hist_398_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualGraphPainter::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Hist_398_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TVirtualGraphPainter::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Hist_398_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TVirtualGraphPainter::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Hist_398_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Hist_398_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualGraphPainter::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Hist_398_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TVirtualGraphPainter::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Hist_398_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualGraphPainter::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Hist_398_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TVirtualGraphPainter::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TVirtualGraphPainter", 2174, G__G__Hist_398_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Hist_398_0_25, (int) ('u'), G__get_linked_tagnum(&G__G__HistLN_TVirtualGraphPainter), -1, 1, 1, 1, 1, 0, "u 'TVirtualGraphPainter' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncROOTcLcLMathcLcLWrappedMultiTF1(void) {
   /* ROOT::Math::WrappedMultiTF1 */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_ROOTcLcLMathcLcLWrappedMultiTF1));
   G__memfunc_setup("WrappedMultiTF1",1449,G__G__Hist_401_0_1, 105, G__get_linked_tagnum(&G__G__HistLN_ROOTcLcLMathcLcLWrappedMultiTF1), -1, 0, 2, 1, 1, 0, 
"u 'TF1' - 1 - f h - - 0 '0' dim", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WrappedMultiTF1",1449,G__G__Hist_401_0_2, 105, G__get_linked_tagnum(&G__G__HistLN_ROOTcLcLMathcLcLWrappedMultiTF1), -1, 0, 1, 1, 1, 0, "u 'ROOT::Math::WrappedMultiTF1' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Hist_401_0_3, 117, G__get_linked_tagnum(&G__G__HistLN_ROOTcLcLMathcLcLWrappedMultiTF1), -1, 1, 1, 1, 1, 0, "u 'ROOT::Math::WrappedMultiTF1' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clone",497,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_ROOTcLcLMathcLcLIBaseFunctionMultiDim), G__defined_typename("ROOT::Math::IMultiGenFunction"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("NDim",360,(G__InterfaceMethod) NULL,104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Parameters",1044,(G__InterfaceMethod) NULL,68, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetParameters",1344,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "D - - 10 - p", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("NPar",369,(G__InterfaceMethod) NULL,104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ParameterName",1314,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__HistLN_string), -1, 0, 1, 1, 1, 8, "h - - 0 - i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ParameterGradient",1743,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 8, 
"D - - 10 - x D - - 10 - par "
"D - - 0 - grad", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDerivPrecision",1746,G__G__Hist_401_0_11, 121, -1, -1, 0, 1, 3, 1, 0, "d - - 0 - eps", (char*)NULL, (void*) G__func2void( (void (*)(double))(&ROOT::Math::WrappedMultiTF1::SetDerivPrecision) ), 0);
   G__memfunc_setup("GetDerivPrecision",1734,G__G__Hist_401_0_12, 100, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (double (*)())(&ROOT::Math::WrappedMultiTF1::GetDerivPrecision) ), 0);
   G__memfunc_setup("DoEvalPar",862,(G__InterfaceMethod) NULL, 100, -1, -1, 0, 2, 1, 4, 8, 
"D - - 10 - x D - - 10 - p", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoParameterDerivative",2151,(G__InterfaceMethod) NULL, 100, -1, -1, 0, 3, 1, 4, 8, 
"D - - 10 - x D - - 10 - p "
"h - - 0 - ipar", (char*)NULL, (void*) NULL, 1);
   // automatic destructor
   G__memfunc_setup("~WrappedMultiTF1", 1575, G__G__Hist_401_0_15, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncROOTcLcLMathcLcLWrappedTF1(void) {
   /* ROOT::Math::WrappedTF1 */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__HistLN_ROOTcLcLMathcLcLWrappedTF1));
   G__memfunc_setup("WrappedTF1",926,G__G__Hist_402_0_1, 105, G__get_linked_tagnum(&G__G__HistLN_ROOTcLcLMathcLcLWrappedTF1), -1, 0, 1, 1, 1, 0, "u 'TF1' - 1 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WrappedTF1",926,G__G__Hist_402_0_2, 105, G__get_linked_tagnum(&G__G__HistLN_ROOTcLcLMathcLcLWrappedTF1), -1, 0, 1, 1, 1, 0, "u 'ROOT::Math::WrappedTF1' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Hist_402_0_3, 117, G__get_linked_tagnum(&G__G__HistLN_ROOTcLcLMathcLcLWrappedTF1), -1, 1, 1, 1, 1, 0, "u 'ROOT::Math::WrappedTF1' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clone",497,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__HistLN_ROOTcLcLMathcLcLIBaseFunctionOneDim), G__defined_typename("ROOT::Math::IGenFunction"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Parameters",1044,(G__InterfaceMethod) NULL,68, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetParameters",1344,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "D - - 10 - p", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("NPar",369,(G__InterfaceMethod) NULL,104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ParameterName",1314,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__HistLN_string), -1, 0, 1, 1, 1, 8, "h - - 0 - i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ParameterGradient",1743,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 8, 
"d - - 0 - x D - - 10 - par "
"D - - 0 - grad", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FdF",240,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 8, 
"d - - 0 - x d - - 1 - f "
"d - - 1 - deriv", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDerivPrecision",1746,G__G__Hist_402_0_11, 121, -1, -1, 0, 1, 3, 1, 0, "d - - 0 - eps", (char*)NULL, (void*) G__func2void( (void (*)(double))(&ROOT::Math::WrappedTF1::SetDerivPrecision) ), 0);
   G__memfunc_setup("GetDerivPrecision",1734,G__G__Hist_402_0_12, 100, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (double (*)())(&ROOT::Math::WrappedTF1::GetDerivPrecision) ), 0);
   G__memfunc_setup("DoEvalPar",862,(G__InterfaceMethod) NULL, 100, -1, -1, 0, 2, 1, 4, 8, 
"d - - 0 - x D - - 10 - p", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoEval",571,(G__InterfaceMethod) NULL, 100, -1, -1, 0, 1, 1, 4, 8, "d - - 0 - x", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoDerivative",1222,(G__InterfaceMethod) NULL, 100, -1, -1, 0, 1, 1, 4, 8, "d - - 0 - x", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoParameterDerivative",2151,(G__InterfaceMethod) NULL, 100, -1, -1, 0, 3, 1, 4, 8, 
"d - - 0 - x D - - 10 - p "
"h - - 0 - ipar", (char*)NULL, (void*) NULL, 1);
   // automatic destructor
   G__memfunc_setup("~WrappedTF1", 1052, G__G__Hist_402_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}


/*********************************************************
* Member function information setup
*********************************************************/
extern "C" void G__cpp_setup_memfuncG__Hist() {
}

/*********************************************************
* Global variable information setup for each class
*********************************************************/
static void G__cpp_setup_global0() {

   /* Setting up global variables */
   G__resetplocal();

}

static void G__cpp_setup_global1() {
}

static void G__cpp_setup_global2() {
}

static void G__cpp_setup_global3() {
}

static void G__cpp_setup_global4() {
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_EErrorType),-1,-1,1,"kERRORMEAN=0",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_EErrorType),-1,-1,1,"kERRORSPREAD=1",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_EErrorType),-1,-1,1,"kERRORSPREADI=2",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__HistLN_EErrorType),-1,-1,1,"kERRORSPREADG=3",0,(char*)NULL);

   G__resetglobalenv();
}
extern "C" void G__cpp_setup_globalG__Hist() {
  G__cpp_setup_global0();
  G__cpp_setup_global1();
  G__cpp_setup_global2();
  G__cpp_setup_global3();
  G__cpp_setup_global4();
}

/*********************************************************
* 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() {
   G__memfunc_setup("operator*", 918, G__G__Hist__0_858, 117, G__get_linked_tagnum(&G__G__HistLN_TH1C), -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - c1 u 'TH1C' - 11 - h1", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Hist__0_859, 117, G__get_linked_tagnum(&G__G__HistLN_TH1C), -1, 0, 2, 1, 1, 0, 
"u 'TH1C' - 11 - h1 d - 'Double_t' 0 - c1", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Hist__0_860, 117, G__get_linked_tagnum(&G__G__HistLN_TH1C), -1, 0, 2, 1, 1, 0, 
"u 'TH1C' - 11 - h1 u 'TH1C' - 11 - h2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator-", 921, G__G__Hist__0_861, 117, G__get_linked_tagnum(&G__G__HistLN_TH1C), -1, 0, 2, 1, 1, 0, 
"u 'TH1C' - 11 - h1 u 'TH1C' - 11 - h2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Hist__0_862, 117, G__get_linked_tagnum(&G__G__HistLN_TH1C), -1, 0, 2, 1, 1, 0, 
"u 'TH1C' - 11 - h1 u 'TH1C' - 11 - h2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator/", 923, G__G__Hist__0_863, 117, G__get_linked_tagnum(&G__G__HistLN_TH1C), -1, 0, 2, 1, 1, 0, 
"u 'TH1C' - 11 - h1 u 'TH1C' - 11 - h2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Hist__0_864, 117, G__get_linked_tagnum(&G__G__HistLN_TH1S), -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - c1 u 'TH1S' - 11 - h1", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Hist__0_865, 117, G__get_linked_tagnum(&G__G__HistLN_TH1S), -1, 0, 2, 1, 1, 0, 
"u 'TH1S' - 11 - h1 d - 'Double_t' 0 - c1", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Hist__0_866, 117, G__get_linked_tagnum(&G__G__HistLN_TH1S), -1, 0, 2, 1, 1, 0, 
"u 'TH1S' - 11 - h1 u 'TH1S' - 11 - h2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator-", 921, G__G__Hist__0_867, 117, G__get_linked_tagnum(&G__G__HistLN_TH1S), -1, 0, 2, 1, 1, 0, 
"u 'TH1S' - 11 - h1 u 'TH1S' - 11 - h2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Hist__0_868, 117, G__get_linked_tagnum(&G__G__HistLN_TH1S), -1, 0, 2, 1, 1, 0, 
"u 'TH1S' - 11 - h1 u 'TH1S' - 11 - h2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator/", 923, G__G__Hist__0_869, 117, G__get_linked_tagnum(&G__G__HistLN_TH1S), -1, 0, 2, 1, 1, 0, 
"u 'TH1S' - 11 - h1 u 'TH1S' - 11 - h2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Hist__0_870, 117, G__get_linked_tagnum(&G__G__HistLN_TH1I), -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - c1 u 'TH1I' - 11 - h1", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Hist__0_871, 117, G__get_linked_tagnum(&G__G__HistLN_TH1I), -1, 0, 2, 1, 1, 0, 
"u 'TH1I' - 11 - h1 d - 'Double_t' 0 - c1", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Hist__0_872, 117, G__get_linked_tagnum(&G__G__HistLN_TH1I), -1, 0, 2, 1, 1, 0, 
"u 'TH1I' - 11 - h1 u 'TH1I' - 11 - h2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator-", 921, G__G__Hist__0_873, 117, G__get_linked_tagnum(&G__G__HistLN_TH1I), -1, 0, 2, 1, 1, 0, 
"u 'TH1I' - 11 - h1 u 'TH1I' - 11 - h2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Hist__0_874, 117, G__get_linked_tagnum(&G__G__HistLN_TH1I), -1, 0, 2, 1, 1, 0, 
"u 'TH1I' - 11 - h1 u 'TH1I' - 11 - h2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator/", 923, G__G__Hist__0_875, 117, G__get_linked_tagnum(&G__G__HistLN_TH1I), -1, 0, 2, 1, 1, 0, 
"u 'TH1I' - 11 - h1 u 'TH1I' - 11 - h2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Hist__0_876, 117, G__get_linked_tagnum(&G__G__HistLN_TH1F), -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - c1 u 'TH1F' - 11 - h1", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Hist__0_877, 117, G__get_linked_tagnum(&G__G__HistLN_TH1F), -1, 0, 2, 1, 1, 0, 
"u 'TH1F' - 11 - h1 d - 'Double_t' 0 - c1", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Hist__0_878, 117, G__get_linked_tagnum(&G__G__HistLN_TH1F), -1, 0, 2, 1, 1, 0, 
"u 'TH1F' - 11 - h1 u 'TH1F' - 11 - h2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator-", 921, G__G__Hist__0_879, 117, G__get_linked_tagnum(&G__G__HistLN_TH1F), -1, 0, 2, 1, 1, 0, 
"u 'TH1F' - 11 - h1 u 'TH1F' - 11 - h2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Hist__0_880, 117, G__get_linked_tagnum(&G__G__HistLN_TH1F), -1, 0, 2, 1, 1, 0, 
"u 'TH1F' - 11 - h1 u 'TH1F' - 11 - h2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator/", 923, G__G__Hist__0_881, 117, G__get_linked_tagnum(&G__G__HistLN_TH1F), -1, 0, 2, 1, 1, 0, 
"u 'TH1F' - 11 - h1 u 'TH1F' - 11 - h2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Hist__0_882, 117, G__get_linked_tagnum(&G__G__HistLN_TH1D), -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - c1 u 'TH1D' - 11 - h1", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Hist__0_883, 117, G__get_linked_tagnum(&G__G__HistLN_TH1D), -1, 0, 2, 1, 1, 0, 
"u 'TH1D' - 11 - h1 d - 'Double_t' 0 - c1", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Hist__0_884, 117, G__get_linked_tagnum(&G__G__HistLN_TH1D), -1, 0, 2, 1, 1, 0, 
"u 'TH1D' - 11 - h1 u 'TH1D' - 11 - h2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator-", 921, G__G__Hist__0_885, 117, G__get_linked_tagnum(&G__G__HistLN_TH1D), -1, 0, 2, 1, 1, 0, 
"u 'TH1D' - 11 - h1 u 'TH1D' - 11 - h2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Hist__0_886, 117, G__get_linked_tagnum(&G__G__HistLN_TH1D), -1, 0, 2, 1, 1, 0, 
"u 'TH1D' - 11 - h1 u 'TH1D' - 11 - h2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator/", 923, G__G__Hist__0_887, 117, G__get_linked_tagnum(&G__G__HistLN_TH1D), -1, 0, 2, 1, 1, 0, 
"u 'TH1D' - 11 - h1 u 'TH1D' - 11 - h2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("R__H", 344, G__G__Hist__0_888, 85, G__get_linked_tagnum(&G__G__HistLN_TH1), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - hid", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("R__H", 344, G__G__Hist__0_889, 85, G__get_linked_tagnum(&G__G__HistLN_TH1), -1, 0, 1, 1, 1, 0, "C - - 10 - hname", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Hist__0_890, 117, G__get_linked_tagnum(&G__G__HistLN_TH2C), -1, 0, 2, 1, 1, 0, 
"f - 'Float_t' 0 - c1 u 'TH2C' - 1 - h1", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Hist__0_891, 117, G__get_linked_tagnum(&G__G__HistLN_TH2C), -1, 0, 2, 1, 1, 0, 
"u 'TH2C' - 1 - h1 f - 'Float_t' 0 - c1", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Hist__0_892, 117, G__get_linked_tagnum(&G__G__HistLN_TH2C), -1, 0, 2, 1, 1, 0, 
"u 'TH2C' - 1 - h1 u 'TH2C' - 1 - h2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator-", 921, G__G__Hist__0_893, 117, G__get_linked_tagnum(&G__G__HistLN_TH2C), -1, 0, 2, 1, 1, 0, 
"u 'TH2C' - 1 - h1 u 'TH2C' - 1 - h2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Hist__0_894, 117, G__get_linked_tagnum(&G__G__HistLN_TH2C), -1, 0, 2, 1, 1, 0, 
"u 'TH2C' - 1 - h1 u 'TH2C' - 1 - h2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator/", 923, G__G__Hist__0_895, 117, G__get_linked_tagnum(&G__G__HistLN_TH2C), -1, 0, 2, 1, 1, 0, 
"u 'TH2C' - 1 - h1 u 'TH2C' - 1 - h2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Hist__0_896, 117, G__get_linked_tagnum(&G__G__HistLN_TH2S), -1, 0, 2, 1, 1, 0, 
"f - 'Float_t' 0 - c1 u 'TH2S' - 1 - h1", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Hist__0_897, 117, G__get_linked_tagnum(&G__G__HistLN_TH2S), -1, 0, 2, 1, 1, 0, 
"u 'TH2S' - 1 - h1 f - 'Float_t' 0 - c1", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Hist__0_898, 117, G__get_linked_tagnum(&G__G__HistLN_TH2S), -1, 0, 2, 1, 1, 0, 
"u 'TH2S' - 1 - h1 u 'TH2S' - 1 - h2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator-", 921, G__G__Hist__0_899, 117, G__get_linked_tagnum(&G__G__HistLN_TH2S), -1, 0, 2, 1, 1, 0, 
"u 'TH2S' - 1 - h1 u 'TH2S' - 1 - h2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Hist__0_900, 117, G__get_linked_tagnum(&G__G__HistLN_TH2S), -1, 0, 2, 1, 1, 0, 
"u 'TH2S' - 1 - h1 u 'TH2S' - 1 - h2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator/", 923, G__G__Hist__0_901, 117, G__get_linked_tagnum(&G__G__HistLN_TH2S), -1, 0, 2, 1, 1, 0, 
"u 'TH2S' - 1 - h1 u 'TH2S' - 1 - h2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Hist__0_902, 117, G__get_linked_tagnum(&G__G__HistLN_TH2I), -1, 0, 2, 1, 1, 0, 
"f - 'Float_t' 0 - c1 u 'TH2I' - 1 - h1", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Hist__0_903, 117, G__get_linked_tagnum(&G__G__HistLN_TH2I), -1, 0, 2, 1, 1, 0, 
"u 'TH2I' - 1 - h1 f - 'Float_t' 0 - c1", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Hist__0_904, 117, G__get_linked_tagnum(&G__G__HistLN_TH2I), -1, 0, 2, 1, 1, 0, 
"u 'TH2I' - 1 - h1 u 'TH2I' - 1 - h2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator-", 921, G__G__Hist__0_905, 117, G__get_linked_tagnum(&G__G__HistLN_TH2I), -1, 0, 2, 1, 1, 0, 
"u 'TH2I' - 1 - h1 u 'TH2I' - 1 - h2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Hist__0_906, 117, G__get_linked_tagnum(&G__G__HistLN_TH2I), -1, 0, 2, 1, 1, 0, 
"u 'TH2I' - 1 - h1 u 'TH2I' - 1 - h2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator/", 923, G__G__Hist__0_907, 117, G__get_linked_tagnum(&G__G__HistLN_TH2I), -1, 0, 2, 1, 1, 0, 
"u 'TH2I' - 1 - h1 u 'TH2I' - 1 - h2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Hist__0_908, 117, G__get_linked_tagnum(&G__G__HistLN_TH2F), -1, 0, 2, 1, 1, 0, 
"f - 'Float_t' 0 - c1 u 'TH2F' - 1 - h1", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Hist__0_909, 117, G__get_linked_tagnum(&G__G__HistLN_TH2F), -1, 0, 2, 1, 1, 0, 
"u 'TH2F' - 1 - h1 f - 'Float_t' 0 - c1", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Hist__0_910, 117, G__get_linked_tagnum(&G__G__HistLN_TH2F), -1, 0, 2, 1, 1, 0, 
"u 'TH2F' - 1 - h1 u 'TH2F' - 1 - h2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator-", 921, G__G__Hist__0_911, 117, G__get_linked_tagnum(&G__G__HistLN_TH2F), -1, 0, 2, 1, 1, 0, 
"u 'TH2F' - 1 - h1 u 'TH2F' - 1 - h2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Hist__0_912, 117, G__get_linked_tagnum(&G__G__HistLN_TH2F), -1, 0, 2, 1, 1, 0, 
"u 'TH2F' - 1 - h1 u 'TH2F' - 1 - h2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator/", 923, G__G__Hist__0_913, 117, G__get_linked_tagnum(&G__G__HistLN_TH2F), -1, 0, 2, 1, 1, 0, 
"u 'TH2F' - 1 - h1 u 'TH2F' - 1 - h2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Hist__0_914, 117, G__get_linked_tagnum(&G__G__HistLN_TH2D), -1, 0, 2, 1, 1, 0, 
"f - 'Float_t' 0 - c1 u 'TH2D' - 1 - h1", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Hist__0_915, 117, G__get_linked_tagnum(&G__G__HistLN_TH2D), -1, 0, 2, 1, 1, 0, 
"u 'TH2D' - 1 - h1 f - 'Float_t' 0 - c1", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Hist__0_916, 117, G__get_linked_tagnum(&G__G__HistLN_TH2D), -1, 0, 2, 1, 1, 0, 
"u 'TH2D' - 1 - h1 u 'TH2D' - 1 - h2", (char*) NULL
, (void*) NULL, 0);
}

static void G__cpp_setup_func9() {
   G__memfunc_setup("operator-", 921, G__G__Hist__0_917, 117, G__get_linked_tagnum(&G__G__HistLN_TH2D), -1, 0, 2, 1, 1, 0, 
"u 'TH2D' - 1 - h1 u 'TH2D' - 1 - h2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Hist__0_918, 117, G__get_linked_tagnum(&G__G__HistLN_TH2D), -1, 0, 2, 1, 1, 0, 
"u 'TH2D' - 1 - h1 u 'TH2D' - 1 - h2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator/", 923, G__G__Hist__0_919, 117, G__get_linked_tagnum(&G__G__HistLN_TH2D), -1, 0, 2, 1, 1, 0, 
"u 'TH2D' - 1 - h1 u 'TH2D' - 1 - h2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Hist__0_920, 117, G__get_linked_tagnum(&G__G__HistLN_TH3C), -1, 0, 2, 1, 1, 0, 
"f - 'Float_t' 0 - c1 u 'TH3C' - 1 - h1", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Hist__0_921, 117, G__get_linked_tagnum(&G__G__HistLN_TH3C), -1, 0, 2, 1, 1, 0, 
"u 'TH3C' - 1 - h1 f - 'Float_t' 0 - c1", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Hist__0_922, 117, G__get_linked_tagnum(&G__G__HistLN_TH3C), -1, 0, 2, 1, 1, 0, 
"u 'TH3C' - 1 - h1 u 'TH3C' - 1 - h2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator-", 921, G__G__Hist__0_923, 117, G__get_linked_tagnum(&G__G__HistLN_TH3C), -1, 0, 2, 1, 1, 0, 
"u 'TH3C' - 1 - h1 u 'TH3C' - 1 - h2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Hist__0_924, 117, G__get_linked_tagnum(&G__G__HistLN_TH3C), -1, 0, 2, 1, 1, 0, 
"u 'TH3C' - 1 - h1 u 'TH3C' - 1 - h2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator/", 923, G__G__Hist__0_925, 117, G__get_linked_tagnum(&G__G__HistLN_TH3C), -1, 0, 2, 1, 1, 0, 
"u 'TH3C' - 1 - h1 u 'TH3C' - 1 - h2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Hist__0_926, 117, G__get_linked_tagnum(&G__G__HistLN_TH3S), -1, 0, 2, 1, 1, 0, 
"f - 'Float_t' 0 - c1 u 'TH3S' - 1 - h1", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Hist__0_927, 117, G__get_linked_tagnum(&G__G__HistLN_TH3S), -1, 0, 2, 1, 1, 0, 
"u 'TH3S' - 1 - h1 f - 'Float_t' 0 - c1", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Hist__0_928, 117, G__get_linked_tagnum(&G__G__HistLN_TH3S), -1, 0, 2, 1, 1, 0, 
"u 'TH3S' - 1 - h1 u 'TH3S' - 1 - h2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator-", 921, G__G__Hist__0_929, 117, G__get_linked_tagnum(&G__G__HistLN_TH3S), -1, 0, 2, 1, 1, 0, 
"u 'TH3S' - 1 - h1 u 'TH3S' - 1 - h2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Hist__0_930, 117, G__get_linked_tagnum(&G__G__HistLN_TH3S), -1, 0, 2, 1, 1, 0, 
"u 'TH3S' - 1 - h1 u 'TH3S' - 1 - h2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator/", 923, G__G__Hist__0_931, 117, G__get_linked_tagnum(&G__G__HistLN_TH3S), -1, 0, 2, 1, 1, 0, 
"u 'TH3S' - 1 - h1 u 'TH3S' - 1 - h2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Hist__0_932, 117, G__get_linked_tagnum(&G__G__HistLN_TH3I), -1, 0, 2, 1, 1, 0, 
"f - 'Float_t' 0 - c1 u 'TH3I' - 1 - h1", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Hist__0_933, 117, G__get_linked_tagnum(&G__G__HistLN_TH3I), -1, 0, 2, 1, 1, 0, 
"u 'TH3I' - 1 - h1 f - 'Float_t' 0 - c1", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Hist__0_934, 117, G__get_linked_tagnum(&G__G__HistLN_TH3I), -1, 0, 2, 1, 1, 0, 
"u 'TH3I' - 1 - h1 u 'TH3I' - 1 - h2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator-", 921, G__G__Hist__0_935, 117, G__get_linked_tagnum(&G__G__HistLN_TH3I), -1, 0, 2, 1, 1, 0, 
"u 'TH3I' - 1 - h1 u 'TH3I' - 1 - h2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Hist__0_936, 117, G__get_linked_tagnum(&G__G__HistLN_TH3I), -1, 0, 2, 1, 1, 0, 
"u 'TH3I' - 1 - h1 u 'TH3I' - 1 - h2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator/", 923, G__G__Hist__0_937, 117, G__get_linked_tagnum(&G__G__HistLN_TH3I), -1, 0, 2, 1, 1, 0, 
"u 'TH3I' - 1 - h1 u 'TH3I' - 1 - h2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Hist__0_938, 117, G__get_linked_tagnum(&G__G__HistLN_TH3F), -1, 0, 2, 1, 1, 0, 
"f - 'Float_t' 0 - c1 u 'TH3F' - 1 - h1", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Hist__0_939, 117, G__get_linked_tagnum(&G__G__HistLN_TH3F), -1, 0, 2, 1, 1, 0, 
"u 'TH3F' - 1 - h1 f - 'Float_t' 0 - c1", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Hist__0_940, 117, G__get_linked_tagnum(&G__G__HistLN_TH3F), -1, 0, 2, 1, 1, 0, 
"u 'TH3F' - 1 - h1 u 'TH3F' - 1 - h2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator-", 921, G__G__Hist__0_941, 117, G__get_linked_tagnum(&G__G__HistLN_TH3F), -1, 0, 2, 1, 1, 0, 
"u 'TH3F' - 1 - h1 u 'TH3F' - 1 - h2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Hist__0_942, 117, G__get_linked_tagnum(&G__G__HistLN_TH3F), -1, 0, 2, 1, 1, 0, 
"u 'TH3F' - 1 - h1 u 'TH3F' - 1 - h2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator/", 923, G__G__Hist__0_943, 117, G__get_linked_tagnum(&G__G__HistLN_TH3F), -1, 0, 2, 1, 1, 0, 
"u 'TH3F' - 1 - h1 u 'TH3F' - 1 - h2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Hist__0_944, 117, G__get_linked_tagnum(&G__G__HistLN_TH3D), -1, 0, 2, 1, 1, 0, 
"f - 'Float_t' 0 - c1 u 'TH3D' - 1 - h1", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Hist__0_945, 117, G__get_linked_tagnum(&G__G__HistLN_TH3D), -1, 0, 2, 1, 1, 0, 
"u 'TH3D' - 1 - h1 f - 'Float_t' 0 - c1", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Hist__0_946, 117, G__get_linked_tagnum(&G__G__HistLN_TH3D), -1, 0, 2, 1, 1, 0, 
"u 'TH3D' - 1 - h1 u 'TH3D' - 1 - h2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator-", 921, G__G__Hist__0_947, 117, G__get_linked_tagnum(&G__G__HistLN_TH3D), -1, 0, 2, 1, 1, 0, 
"u 'TH3D' - 1 - h1 u 'TH3D' - 1 - h2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Hist__0_948, 117, G__get_linked_tagnum(&G__G__HistLN_TH3D), -1, 0, 2, 1, 1, 0, 
"u 'TH3D' - 1 - h1 u 'TH3D' - 1 - h2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator/", 923, G__G__Hist__0_949, 117, G__get_linked_tagnum(&G__G__HistLN_TH3D), -1, 0, 2, 1, 1, 0, 
"u 'TH3D' - 1 - h1 u 'TH3D' - 1 - h2", (char*) NULL
, (void*) NULL, 0);
}

static void G__cpp_setup_func10() {

   G__resetifuncposition();
}

extern "C" void G__cpp_setup_funcG__Hist() {
  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();
}

/*********************************************************
* Class,struct,union,enum tag information setup
*********************************************************/
/* Setup class/struct taginfo */
G__linked_taginfo G__G__HistLN_TClass = { "TClass" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TBuffer = { "TBuffer" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TDirectory = { "TDirectory" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TMemberInspector = { "TMemberInspector" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TObject = { "TObject" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TNamed = { "TNamed" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TString = { "TString" , 99 , -1 };
G__linked_taginfo G__G__HistLN_ROOT = { "ROOT" , 110 , -1 };
G__linked_taginfo G__G__HistLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR = { "basic_ostream<char,char_traits<char> >" , 99 , -1 };
G__linked_taginfo G__G__HistLN_string = { "string" , 99 , -1 };
G__linked_taginfo G__G__HistLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR = { "vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >" , 99 , -1 };
G__linked_taginfo G__G__HistLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TList = { "TList" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TBrowser = { "TBrowser" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TObjArray = { "TObjArray" , 99 , -1 };
G__linked_taginfo G__G__HistLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR = { "vector<TVirtualArray*,allocator<TVirtualArray*> >" , 99 , -1 };
G__linked_taginfo G__G__HistLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TVirtualArray*,allocator<TVirtualArray*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__HistLN_Foption_t = { "Foption_t" , 115 , -1 };
G__linked_taginfo G__G__HistLN_TH1 = { "TH1" , 99 , -1 };
G__linked_taginfo G__G__HistLN_THnSparse = { "THnSparse" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TF1 = { "TF1" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TF2 = { "TF2" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TGraph = { "TGraph" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TGraphErrors = { "TGraphErrors" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TGraph2D = { "TGraph2D" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TMultiGraph = { "TMultiGraph" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TFitResult = { "TFitResult" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TFitResultPtr = { "TFitResultPtr" , 99 , -1 };
G__linked_taginfo G__G__HistLN_ROOTcLcLMath = { "ROOT::Math" , 110 , -1 };
G__linked_taginfo G__G__HistLN_ROOTcLcLMathcLcLMinimizerOptions = { "ROOT::Math::MinimizerOptions" , 99 , -1 };
G__linked_taginfo G__G__HistLN_ROOTcLcLFit = { "ROOT::Fit" , 110 , -1 };
G__linked_taginfo G__G__HistLN_ROOTcLcLFitcLcLFitResult = { "ROOT::Fit::FitResult" , 99 , -1 };
G__linked_taginfo G__G__HistLN_ROOTcLcLFitcLcLBinData = { "ROOT::Fit::BinData" , 99 , -1 };
G__linked_taginfo G__G__HistLN_ROOTcLcLFitcLcLUnBinData = { "ROOT::Fit::UnBinData" , 99 , -1 };
G__linked_taginfo G__G__HistLN_ROOTcLcLFitcLcLSparseData = { "ROOT::Fit::SparseData" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TAttAxis = { "TAttAxis" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TArray = { "TArray" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TArrayD = { "TArrayD" , 99 , -1 };
G__linked_taginfo G__G__HistLN_THashList = { "THashList" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TAxis = { "TAxis" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TAxiscLcLdA = { "TAxis::$" , 101 , -1 };
G__linked_taginfo G__G__HistLN_TMethodCall = { "TMethodCall" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TVirtualFitter = { "TVirtualFitter" , 99 , -1 };
G__linked_taginfo G__G__HistLN_ROOTcLcLMathcLcLIBaseFunctionOneDim = { "ROOT::Math::IBaseFunctionOneDim" , 99 , -1 };
G__linked_taginfo G__G__HistLN_ROOTcLcLMathcLcLIBaseFunctionMultiDim = { "ROOT::Math::IBaseFunctionMultiDim" , 99 , -1 };
G__linked_taginfo G__G__HistLN_ROOTcLcLMathcLcLIParametricFunctionOneDim = { "ROOT::Math::IParametricFunctionOneDim" , 99 , -1 };
G__linked_taginfo G__G__HistLN_ROOTcLcLMathcLcLIParametricGradFunctionOneDim = { "ROOT::Math::IParametricGradFunctionOneDim" , 99 , -1 };
G__linked_taginfo G__G__HistLN_ROOTcLcLMathcLcLIParametricFunctionMultiDim = { "ROOT::Math::IParametricFunctionMultiDim" , 99 , -1 };
G__linked_taginfo G__G__HistLN_ROOTcLcLMathcLcLIParametricGradFunctionMultiDim = { "ROOT::Math::IParametricGradFunctionMultiDim" , 99 , -1 };
G__linked_taginfo G__G__HistLN_ROOTcLcLMathcLcLMinimizer = { "ROOT::Math::Minimizer" , 99 , -1 };
G__linked_taginfo G__G__HistLN_ROOTcLcLFitcLcLFitConfig = { "ROOT::Fit::FitConfig" , 99 , -1 };
G__linked_taginfo G__G__HistLN_vectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgR = { "vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >" , 99 , -1 };
G__linked_taginfo G__G__HistLN_reverse_iteratorlEvectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__HistLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR = { "vector<unsigned int,allocator<unsigned int> >" , 99 , -1 };
G__linked_taginfo G__G__HistLN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<unsigned int,allocator<unsigned int> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__HistLN_vectorlEdoublecOallocatorlEdoublegRsPgR = { "vector<double,allocator<double> >" , 99 , -1 };
G__linked_taginfo G__G__HistLN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR = { "reverse_iterator<vector<double,allocator<double> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__HistLN_pairlEdoublecOdoublegR = { "pair<double,double>" , 115 , -1 };
G__linked_taginfo G__G__HistLN_maplEunsignedsPintcOpairlEdoublecOdoublegRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcOpairlEdoublecOdoublegRsPgRsPgRsPgR = { "map<unsigned int,pair<double,double>,less<unsigned int>,allocator<pair<const unsigned int,pair<double,double> > > >" , 99 , -1 };
G__linked_taginfo G__G__HistLN_vectorlEstringcOallocatorlEstringgRsPgR = { "vector<string,allocator<string> >" , 99 , -1 };
G__linked_taginfo G__G__HistLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<string,allocator<string> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__HistLN_auto_ptrlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR = { "auto_ptr<ROOT::Math::IBaseFunctionMultiDim>" , 99 , -1 };
G__linked_taginfo G__G__HistLN_vectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgR = { "vector<pair<double,double>,allocator<pair<double,double> > >" , 99 , -1 };
G__linked_taginfo G__G__HistLN_reverse_iteratorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<pair<double,double>,allocator<pair<double,double> > >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__HistLN_vectorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRcOallocatorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRsPgRsPgR = { "vector<vector<pair<double,double>,allocator<pair<double,double> > >,allocator<vector<pair<double,double>,allocator<pair<double,double> > > > >" , 99 , -1 };
G__linked_taginfo G__G__HistLN_reverse_iteratorlEvectorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRcOallocatorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<vector<pair<double,double>,allocator<pair<double,double> > >,allocator<vector<pair<double,double>,allocator<pair<double,double> > > > >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__HistLN_ROOTcLcLFitcLcLFitData = { "ROOT::Fit::FitData" , 99 , -1 };
G__linked_taginfo G__G__HistLN_vectorlEconstsPdoublemUcOallocatorlEconstsPdoublemUgRsPgR = { "vector<const double*,allocator<const double*> >" , 99 , -1 };
G__linked_taginfo G__G__HistLN_reverse_iteratorlEvectorlEconstsPdoublemUcOallocatorlEconstsPdoublemUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<const double*,allocator<const double*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TBackCompFitter = { "TBackCompFitter" , 99 , -1 };
G__linked_taginfo G__G__HistLN_auto_ptrlEROOTcLcLFitcLcLFittergR = { "auto_ptr<ROOT::Fit::Fitter>" , 99 , -1 };
G__linked_taginfo G__G__HistLN_auto_ptrlEROOTcLcLFitcLcLFitDatagR = { "auto_ptr<ROOT::Fit::FitData>" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TBackCompFittercLcLdA = { "TBackCompFitter::$" , 101 , -1 };
G__linked_taginfo G__G__HistLN_TBinomialEfficiencyFitter = { "TBinomialEfficiencyFitter" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TConfidenceLevel = { "TConfidenceLevel" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TAttLine = { "TAttLine" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TAttFill = { "TAttFill" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TAttMarker = { "TAttMarker" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TCollection = { "TCollection" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TGraphAsymmErrors = { "TGraphAsymmErrors" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TH2 = { "TH2" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TEfficiency = { "TEfficiency" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TEfficiencycLcLEStatOption = { "TEfficiency::EStatOption" , 101 , -1 };
G__linked_taginfo G__G__HistLN_TEfficiencycLcLdA = { "TEfficiency::$" , 101 , -1 };
G__linked_taginfo G__G__HistLN_TBits = { "TBits" , 99 , -1 };
G__linked_taginfo G__G__HistLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR = { "iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&>" , 115 , -1 };
G__linked_taginfo G__G__HistLN_TFormulaPrimitive = { "TFormulaPrimitive" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TOperOffset = { "TOperOffset" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TFormula = { "TFormula" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TFormulacLcLdA = { "TFormula::$" , 101 , -1 };
G__linked_taginfo G__G__HistLN_ROOTcLcLMathcLcLParamFunctor = { "ROOT::Math::ParamFunctor" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TF1cLcLdA = { "TF1::$" , 101 , -1 };
G__linked_taginfo G__G__HistLN_TF12 = { "TF12" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TF3 = { "TF3" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TMatrixTBaselEfloatgR = { "TMatrixTBase<float>" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TMatrixTBaselEdoublegR = { "TMatrixTBase<double>" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TVectorTlEfloatgR = { "TVectorT<float>" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TVectorTlEdoublegR = { "TVectorT<double>" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TElementActionTlEdoublegR = { "TElementActionT<double>" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TElementPosActionTlEdoublegR = { "TElementPosActionT<double>" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TMatrixTSymlEdoublegR = { "TMatrixTSym<double>" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TMatrixTlEdoublegR = { "TMatrixT<double>" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TMatrixTRow_constlEdoublegR = { "TMatrixTRow_const<double>" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TMatrixTRowlEdoublegR = { "TMatrixTRow<double>" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TMatrixTColumn_constlEdoublegR = { "TMatrixTColumn_const<double>" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TMatrixTDiag_constlEdoublegR = { "TMatrixTDiag_const<double>" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TMatrixTFlat_constlEdoublegR = { "TMatrixTFlat_const<double>" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TMatrixTSub_constlEdoublegR = { "TMatrixTSub_const<double>" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TMatrixTSparseRow_constlEdoublegR = { "TMatrixTSparseRow_const<double>" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TMatrixTSparselEdoublegR = { "TMatrixTSparse<double>" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TMatrixTSparseDiag_constlEdoublegR = { "TMatrixTSparseDiag_const<double>" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TMatrixTColumnlEdoublegR = { "TMatrixTColumn<double>" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TMatrixTDiaglEdoublegR = { "TMatrixTDiag<double>" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TMatrixTFlatlEdoublegR = { "TMatrixTFlat<double>" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TMatrixTSublEdoublegR = { "TMatrixTSub<double>" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TMatrixTSparseRowlEdoublegR = { "TMatrixTSparseRow<double>" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TMatrixTSparseDiaglEdoublegR = { "TMatrixTSparseDiag<double>" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TFractionFitter = { "TFractionFitter" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TVirtualHistPainter = { "TVirtualHistPainter" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TH2D = { "TH2D" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TGraph2DErrors = { "TGraph2DErrors" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TH1F = { "TH1F" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TSpline = { "TSpline" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TGraphcLcLdA = { "TGraph::$" , 101 , -1 };
G__linked_taginfo G__G__HistLN_TGraphBentErrors = { "TGraphBentErrors" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TGraphDelaunay = { "TGraphDelaunay" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TGraphSmooth = { "TGraphSmooth" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TGraphTime = { "TGraphTime" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TArrayC = { "TArrayC" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TArrayS = { "TArrayS" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TArrayI = { "TArrayI" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TArrayF = { "TArrayF" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TH1D = { "TH1D" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TVirtualFFT = { "TVirtualFFT" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TH1cLcLdA = { "TH1::$" , 101 , -1 };
G__linked_taginfo G__G__HistLN_TH1C = { "TH1C" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TH1S = { "TH1S" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TH1I = { "TH1I" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TH1K = { "TH1K" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TProfile = { "TProfile" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TH2C = { "TH2C" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TH2S = { "TH2S" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TH2I = { "TH2I" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TH2F = { "TH2F" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TH2PolyBin = { "TH2PolyBin" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TH2Poly = { "TH2Poly" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TAtt3D = { "TAtt3D" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TProfile2D = { "TProfile2D" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TH3 = { "TH3" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TH3C = { "TH3C" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TH3S = { "TH3S" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TH3I = { "TH3I" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TH3F = { "TH3F" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TH3D = { "TH3D" , 99 , -1 };
G__linked_taginfo G__G__HistLN_THLimitsFinder = { "THLimitsFinder" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TExMap = { "TExMap" , 99 , -1 };
G__linked_taginfo G__G__HistLN_THnSparseArrayChunk = { "THnSparseArrayChunk" , 99 , -1 };
G__linked_taginfo G__G__HistLN_THnSparseCompactBinCoord = { "THnSparseCompactBinCoord" , 99 , -1 };
G__linked_taginfo G__G__HistLN_THnSparsecLcLdA = { "THnSparse::$" , 101 , -1 };
G__linked_taginfo G__G__HistLN_THnSparseTlETArrayDgR = { "THnSparseT<TArrayD>" , 99 , -1 };
G__linked_taginfo G__G__HistLN_THnSparseTlETArrayFgR = { "THnSparseT<TArrayF>" , 99 , -1 };
G__linked_taginfo G__G__HistLN_THnSparseTlETArrayLgR = { "THnSparseT<TArrayL>" , 99 , -1 };
G__linked_taginfo G__G__HistLN_THnSparseTlETArrayIgR = { "THnSparseT<TArrayI>" , 99 , -1 };
G__linked_taginfo G__G__HistLN_THnSparseTlETArraySgR = { "THnSparseT<TArrayS>" , 99 , -1 };
G__linked_taginfo G__G__HistLN_THnSparseTlETArrayCgR = { "THnSparseT<TArrayC>" , 99 , -1 };
G__linked_taginfo G__G__HistLN_THStack = { "THStack" , 99 , -1 };
G__linked_taginfo G__G__HistLN_ROOTcLcLMathcLcLIGradientOneDim = { "ROOT::Math::IGradientOneDim" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TKDE = { "TKDE" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TKDEcLcLEKernelType = { "TKDE::EKernelType" , 101 , -1 };
G__linked_taginfo G__G__HistLN_TKDEcLcLEIteration = { "TKDE::EIteration" , 101 , -1 };
G__linked_taginfo G__G__HistLN_TKDEcLcLEMirror = { "TKDE::EMirror" , 101 , -1 };
G__linked_taginfo G__G__HistLN_TKDEcLcLEBinning = { "TKDE::EBinning" , 101 , -1 };
G__linked_taginfo G__G__HistLN_TKDEcLcLTKernel = { "TKDE::TKernel" , 99 , -1 };
G__linked_taginfo G__G__HistLN_vectorlEboolcOallocatorlEboolgRsPgR = { "vector<bool,allocator<bool> >" , 99 , -1 };
G__linked_taginfo G__G__HistLN_reverse_iteratorlEvectorlEboolcOallocatorlEboolgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<bool,allocator<bool> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TLimitDataSource = { "TLimitDataSource" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TRandom = { "TRandom" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TOrdCollection = { "TOrdCollection" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TLimit = { "TLimit" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TMultiDimFit = { "TMultiDimFit" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TMultiDimFitcLcLEMDFPolyType = { "TMultiDimFit::EMDFPolyType" , 101 , -1 };
G__linked_taginfo G__G__HistLN_TPolyMarker = { "TPolyMarker" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TPrincipal = { "TPrincipal" , 99 , -1 };
G__linked_taginfo G__G__HistLN_EErrorType = { "EErrorType" , 101 , -1 };
G__linked_taginfo G__G__HistLN_TProfile3D = { "TProfile3D" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TSplinePoly = { "TSplinePoly" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TSplinePoly3 = { "TSplinePoly3" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TSplinePoly5 = { "TSplinePoly5" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TSpline3 = { "TSpline3" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TSpline5 = { "TSpline5" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TSVDUnfold = { "TSVDUnfold" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TUnfold = { "TUnfold" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TUnfoldcLcLEConstraint = { "TUnfold::EConstraint" , 101 , -1 };
G__linked_taginfo G__G__HistLN_TUnfoldcLcLERegMode = { "TUnfold::ERegMode" , 101 , -1 };
G__linked_taginfo G__G__HistLN_TUnfoldcLcLEHistMap = { "TUnfold::EHistMap" , 101 , -1 };
G__linked_taginfo G__G__HistLN_TMap = { "TMap" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TUnfoldSys = { "TUnfoldSys" , 99 , -1 };
G__linked_taginfo G__G__HistLN_TUnfoldSyscLcLESysErrMode = { "TUnfoldSys::ESysErrMode" , 101 , -1 };
G__linked_taginfo G__G__HistLN_TVirtualGraphPainter = { "TVirtualGraphPainter" , 99 , -1 };
G__linked_taginfo G__G__HistLN_ROOTcLcLMathcLcLIBaseParam = { "ROOT::Math::IBaseParam" , 99 , -1 };
G__linked_taginfo G__G__HistLN_ROOTcLcLMathcLcLWrappedMultiTF1 = { "ROOT::Math::WrappedMultiTF1" , 99 , -1 };
G__linked_taginfo G__G__HistLN_ROOTcLcLMathcLcLWrappedTF1 = { "ROOT::Math::WrappedTF1" , 99 , -1 };

/* Reset class/struct taginfo */
extern "C" void G__cpp_reset_tagtableG__Hist() {
  G__G__HistLN_TClass.tagnum = -1 ;
  G__G__HistLN_TBuffer.tagnum = -1 ;
  G__G__HistLN_TDirectory.tagnum = -1 ;
  G__G__HistLN_TMemberInspector.tagnum = -1 ;
  G__G__HistLN_TObject.tagnum = -1 ;
  G__G__HistLN_TNamed.tagnum = -1 ;
  G__G__HistLN_TString.tagnum = -1 ;
  G__G__HistLN_ROOT.tagnum = -1 ;
  G__G__HistLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR.tagnum = -1 ;
  G__G__HistLN_string.tagnum = -1 ;
  G__G__HistLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR.tagnum = -1 ;
  G__G__HistLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__HistLN_TList.tagnum = -1 ;
  G__G__HistLN_TBrowser.tagnum = -1 ;
  G__G__HistLN_TObjArray.tagnum = -1 ;
  G__G__HistLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR.tagnum = -1 ;
  G__G__HistLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__HistLN_Foption_t.tagnum = -1 ;
  G__G__HistLN_TH1.tagnum = -1 ;
  G__G__HistLN_THnSparse.tagnum = -1 ;
  G__G__HistLN_TF1.tagnum = -1 ;
  G__G__HistLN_TF2.tagnum = -1 ;
  G__G__HistLN_TGraph.tagnum = -1 ;
  G__G__HistLN_TGraphErrors.tagnum = -1 ;
  G__G__HistLN_TGraph2D.tagnum = -1 ;
  G__G__HistLN_TMultiGraph.tagnum = -1 ;
  G__G__HistLN_TFitResult.tagnum = -1 ;
  G__G__HistLN_TFitResultPtr.tagnum = -1 ;
  G__G__HistLN_ROOTcLcLMath.tagnum = -1 ;
  G__G__HistLN_ROOTcLcLMathcLcLMinimizerOptions.tagnum = -1 ;
  G__G__HistLN_ROOTcLcLFit.tagnum = -1 ;
  G__G__HistLN_ROOTcLcLFitcLcLFitResult.tagnum = -1 ;
  G__G__HistLN_ROOTcLcLFitcLcLBinData.tagnum = -1 ;
  G__G__HistLN_ROOTcLcLFitcLcLUnBinData.tagnum = -1 ;
  G__G__HistLN_ROOTcLcLFitcLcLSparseData.tagnum = -1 ;
  G__G__HistLN_TAttAxis.tagnum = -1 ;
  G__G__HistLN_TArray.tagnum = -1 ;
  G__G__HistLN_TArrayD.tagnum = -1 ;
  G__G__HistLN_THashList.tagnum = -1 ;
  G__G__HistLN_TAxis.tagnum = -1 ;
  G__G__HistLN_TAxiscLcLdA.tagnum = -1 ;
  G__G__HistLN_TMethodCall.tagnum = -1 ;
  G__G__HistLN_TVirtualFitter.tagnum = -1 ;
  G__G__HistLN_ROOTcLcLMathcLcLIBaseFunctionOneDim.tagnum = -1 ;
  G__G__HistLN_ROOTcLcLMathcLcLIBaseFunctionMultiDim.tagnum = -1 ;
  G__G__HistLN_ROOTcLcLMathcLcLIParametricFunctionOneDim.tagnum = -1 ;
  G__G__HistLN_ROOTcLcLMathcLcLIParametricGradFunctionOneDim.tagnum = -1 ;
  G__G__HistLN_ROOTcLcLMathcLcLIParametricFunctionMultiDim.tagnum = -1 ;
  G__G__HistLN_ROOTcLcLMathcLcLIParametricGradFunctionMultiDim.tagnum = -1 ;
  G__G__HistLN_ROOTcLcLMathcLcLMinimizer.tagnum = -1 ;
  G__G__HistLN_ROOTcLcLFitcLcLFitConfig.tagnum = -1 ;
  G__G__HistLN_vectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgR.tagnum = -1 ;
  G__G__HistLN_reverse_iteratorlEvectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__HistLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR.tagnum = -1 ;
  G__G__HistLN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__HistLN_vectorlEdoublecOallocatorlEdoublegRsPgR.tagnum = -1 ;
  G__G__HistLN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__HistLN_pairlEdoublecOdoublegR.tagnum = -1 ;
  G__G__HistLN_maplEunsignedsPintcOpairlEdoublecOdoublegRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcOpairlEdoublecOdoublegRsPgRsPgRsPgR.tagnum = -1 ;
  G__G__HistLN_vectorlEstringcOallocatorlEstringgRsPgR.tagnum = -1 ;
  G__G__HistLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__HistLN_auto_ptrlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR.tagnum = -1 ;
  G__G__HistLN_vectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgR.tagnum = -1 ;
  G__G__HistLN_reverse_iteratorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__HistLN_vectorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRcOallocatorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRsPgRsPgR.tagnum = -1 ;
  G__G__HistLN_reverse_iteratorlEvectorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRcOallocatorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__HistLN_ROOTcLcLFitcLcLFitData.tagnum = -1 ;
  G__G__HistLN_vectorlEconstsPdoublemUcOallocatorlEconstsPdoublemUgRsPgR.tagnum = -1 ;
  G__G__HistLN_reverse_iteratorlEvectorlEconstsPdoublemUcOallocatorlEconstsPdoublemUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__HistLN_TBackCompFitter.tagnum = -1 ;
  G__G__HistLN_auto_ptrlEROOTcLcLFitcLcLFittergR.tagnum = -1 ;
  G__G__HistLN_auto_ptrlEROOTcLcLFitcLcLFitDatagR.tagnum = -1 ;
  G__G__HistLN_TBackCompFittercLcLdA.tagnum = -1 ;
  G__G__HistLN_TBinomialEfficiencyFitter.tagnum = -1 ;
  G__G__HistLN_TConfidenceLevel.tagnum = -1 ;
  G__G__HistLN_TAttLine.tagnum = -1 ;
  G__G__HistLN_TAttFill.tagnum = -1 ;
  G__G__HistLN_TAttMarker.tagnum = -1 ;
  G__G__HistLN_TCollection.tagnum = -1 ;
  G__G__HistLN_TGraphAsymmErrors.tagnum = -1 ;
  G__G__HistLN_TH2.tagnum = -1 ;
  G__G__HistLN_TEfficiency.tagnum = -1 ;
  G__G__HistLN_TEfficiencycLcLEStatOption.tagnum = -1 ;
  G__G__HistLN_TEfficiencycLcLdA.tagnum = -1 ;
  G__G__HistLN_TBits.tagnum = -1 ;
  G__G__HistLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR.tagnum = -1 ;
  G__G__HistLN_TFormulaPrimitive.tagnum = -1 ;
  G__G__HistLN_TOperOffset.tagnum = -1 ;
  G__G__HistLN_TFormula.tagnum = -1 ;
  G__G__HistLN_TFormulacLcLdA.tagnum = -1 ;
  G__G__HistLN_ROOTcLcLMathcLcLParamFunctor.tagnum = -1 ;
  G__G__HistLN_TF1cLcLdA.tagnum = -1 ;
  G__G__HistLN_TF12.tagnum = -1 ;
  G__G__HistLN_TF3.tagnum = -1 ;
  G__G__HistLN_TMatrixTBaselEfloatgR.tagnum = -1 ;
  G__G__HistLN_TMatrixTBaselEdoublegR.tagnum = -1 ;
  G__G__HistLN_TVectorTlEfloatgR.tagnum = -1 ;
  G__G__HistLN_TVectorTlEdoublegR.tagnum = -1 ;
  G__G__HistLN_TElementActionTlEdoublegR.tagnum = -1 ;
  G__G__HistLN_TElementPosActionTlEdoublegR.tagnum = -1 ;
  G__G__HistLN_TMatrixTSymlEdoublegR.tagnum = -1 ;
  G__G__HistLN_TMatrixTlEdoublegR.tagnum = -1 ;
  G__G__HistLN_TMatrixTRow_constlEdoublegR.tagnum = -1 ;
  G__G__HistLN_TMatrixTRowlEdoublegR.tagnum = -1 ;
  G__G__HistLN_TMatrixTColumn_constlEdoublegR.tagnum = -1 ;
  G__G__HistLN_TMatrixTDiag_constlEdoublegR.tagnum = -1 ;
  G__G__HistLN_TMatrixTFlat_constlEdoublegR.tagnum = -1 ;
  G__G__HistLN_TMatrixTSub_constlEdoublegR.tagnum = -1 ;
  G__G__HistLN_TMatrixTSparseRow_constlEdoublegR.tagnum = -1 ;
  G__G__HistLN_TMatrixTSparselEdoublegR.tagnum = -1 ;
  G__G__HistLN_TMatrixTSparseDiag_constlEdoublegR.tagnum = -1 ;
  G__G__HistLN_TMatrixTColumnlEdoublegR.tagnum = -1 ;
  G__G__HistLN_TMatrixTDiaglEdoublegR.tagnum = -1 ;
  G__G__HistLN_TMatrixTFlatlEdoublegR.tagnum = -1 ;
  G__G__HistLN_TMatrixTSublEdoublegR.tagnum = -1 ;
  G__G__HistLN_TMatrixTSparseRowlEdoublegR.tagnum = -1 ;
  G__G__HistLN_TMatrixTSparseDiaglEdoublegR.tagnum = -1 ;
  G__G__HistLN_TFractionFitter.tagnum = -1 ;
  G__G__HistLN_TVirtualHistPainter.tagnum = -1 ;
  G__G__HistLN_TH2D.tagnum = -1 ;
  G__G__HistLN_TGraph2DErrors.tagnum = -1 ;
  G__G__HistLN_TH1F.tagnum = -1 ;
  G__G__HistLN_TSpline.tagnum = -1 ;
  G__G__HistLN_TGraphcLcLdA.tagnum = -1 ;
  G__G__HistLN_TGraphBentErrors.tagnum = -1 ;
  G__G__HistLN_TGraphDelaunay.tagnum = -1 ;
  G__G__HistLN_TGraphSmooth.tagnum = -1 ;
  G__G__HistLN_TGraphTime.tagnum = -1 ;
  G__G__HistLN_TArrayC.tagnum = -1 ;
  G__G__HistLN_TArrayS.tagnum = -1 ;
  G__G__HistLN_TArrayI.tagnum = -1 ;
  G__G__HistLN_TArrayF.tagnum = -1 ;
  G__G__HistLN_TH1D.tagnum = -1 ;
  G__G__HistLN_TVirtualFFT.tagnum = -1 ;
  G__G__HistLN_TH1cLcLdA.tagnum = -1 ;
  G__G__HistLN_TH1C.tagnum = -1 ;
  G__G__HistLN_TH1S.tagnum = -1 ;
  G__G__HistLN_TH1I.tagnum = -1 ;
  G__G__HistLN_TH1K.tagnum = -1 ;
  G__G__HistLN_TProfile.tagnum = -1 ;
  G__G__HistLN_TH2C.tagnum = -1 ;
  G__G__HistLN_TH2S.tagnum = -1 ;
  G__G__HistLN_TH2I.tagnum = -1 ;
  G__G__HistLN_TH2F.tagnum = -1 ;
  G__G__HistLN_TH2PolyBin.tagnum = -1 ;
  G__G__HistLN_TH2Poly.tagnum = -1 ;
  G__G__HistLN_TAtt3D.tagnum = -1 ;
  G__G__HistLN_TProfile2D.tagnum = -1 ;
  G__G__HistLN_TH3.tagnum = -1 ;
  G__G__HistLN_TH3C.tagnum = -1 ;
  G__G__HistLN_TH3S.tagnum = -1 ;
  G__G__HistLN_TH3I.tagnum = -1 ;
  G__G__HistLN_TH3F.tagnum = -1 ;
  G__G__HistLN_TH3D.tagnum = -1 ;
  G__G__HistLN_THLimitsFinder.tagnum = -1 ;
  G__G__HistLN_TExMap.tagnum = -1 ;
  G__G__HistLN_THnSparseArrayChunk.tagnum = -1 ;
  G__G__HistLN_THnSparseCompactBinCoord.tagnum = -1 ;
  G__G__HistLN_THnSparsecLcLdA.tagnum = -1 ;
  G__G__HistLN_THnSparseTlETArrayDgR.tagnum = -1 ;
  G__G__HistLN_THnSparseTlETArrayFgR.tagnum = -1 ;
  G__G__HistLN_THnSparseTlETArrayLgR.tagnum = -1 ;
  G__G__HistLN_THnSparseTlETArrayIgR.tagnum = -1 ;
  G__G__HistLN_THnSparseTlETArraySgR.tagnum = -1 ;
  G__G__HistLN_THnSparseTlETArrayCgR.tagnum = -1 ;
  G__G__HistLN_THStack.tagnum = -1 ;
  G__G__HistLN_ROOTcLcLMathcLcLIGradientOneDim.tagnum = -1 ;
  G__G__HistLN_TKDE.tagnum = -1 ;
  G__G__HistLN_TKDEcLcLEKernelType.tagnum = -1 ;
  G__G__HistLN_TKDEcLcLEIteration.tagnum = -1 ;
  G__G__HistLN_TKDEcLcLEMirror.tagnum = -1 ;
  G__G__HistLN_TKDEcLcLEBinning.tagnum = -1 ;
  G__G__HistLN_TKDEcLcLTKernel.tagnum = -1 ;
  G__G__HistLN_vectorlEboolcOallocatorlEboolgRsPgR.tagnum = -1 ;
  G__G__HistLN_reverse_iteratorlEvectorlEboolcOallocatorlEboolgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__HistLN_TLimitDataSource.tagnum = -1 ;
  G__G__HistLN_TRandom.tagnum = -1 ;
  G__G__HistLN_TOrdCollection.tagnum = -1 ;
  G__G__HistLN_TLimit.tagnum = -1 ;
  G__G__HistLN_TMultiDimFit.tagnum = -1 ;
  G__G__HistLN_TMultiDimFitcLcLEMDFPolyType.tagnum = -1 ;
  G__G__HistLN_TPolyMarker.tagnum = -1 ;
  G__G__HistLN_TPrincipal.tagnum = -1 ;
  G__G__HistLN_EErrorType.tagnum = -1 ;
  G__G__HistLN_TProfile3D.tagnum = -1 ;
  G__G__HistLN_TSplinePoly.tagnum = -1 ;
  G__G__HistLN_TSplinePoly3.tagnum = -1 ;
  G__G__HistLN_TSplinePoly5.tagnum = -1 ;
  G__G__HistLN_TSpline3.tagnum = -1 ;
  G__G__HistLN_TSpline5.tagnum = -1 ;
  G__G__HistLN_TSVDUnfold.tagnum = -1 ;
  G__G__HistLN_TUnfold.tagnum = -1 ;
  G__G__HistLN_TUnfoldcLcLEConstraint.tagnum = -1 ;
  G__G__HistLN_TUnfoldcLcLERegMode.tagnum = -1 ;
  G__G__HistLN_TUnfoldcLcLEHistMap.tagnum = -1 ;
  G__G__HistLN_TMap.tagnum = -1 ;
  G__G__HistLN_TUnfoldSys.tagnum = -1 ;
  G__G__HistLN_TUnfoldSyscLcLESysErrMode.tagnum = -1 ;
  G__G__HistLN_TVirtualGraphPainter.tagnum = -1 ;
  G__G__HistLN_ROOTcLcLMathcLcLIBaseParam.tagnum = -1 ;
  G__G__HistLN_ROOTcLcLMathcLcLWrappedMultiTF1.tagnum = -1 ;
  G__G__HistLN_ROOTcLcLMathcLcLWrappedTF1.tagnum = -1 ;
}


extern "C" void G__cpp_setup_tagtableG__Hist() {

   /* Setting up class,struct,union tag entry */
   G__get_linked_tagnum_fwd(&G__G__HistLN_TClass);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TBuffer);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TDirectory);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TMemberInspector);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TObject);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TNamed);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TString);
   G__get_linked_tagnum_fwd(&G__G__HistLN_ROOT);
   G__get_linked_tagnum_fwd(&G__G__HistLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR);
   G__get_linked_tagnum_fwd(&G__G__HistLN_string);
   G__get_linked_tagnum_fwd(&G__G__HistLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR);
   G__get_linked_tagnum_fwd(&G__G__HistLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TList);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TBrowser);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TObjArray);
   G__get_linked_tagnum_fwd(&G__G__HistLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__HistLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_Foption_t),sizeof(Foption_t),-1,262400,(char*)NULL,G__setup_memvarFoption_t,G__setup_memfuncFoption_t);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TH1),sizeof(TH1),-1,130816,"1-Dim histogram base class",G__setup_memvarTH1,G__setup_memfuncTH1);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_THnSparse),sizeof(THnSparse),-1,327425,"Interfaces of sparse n-dimensional histogram",G__setup_memvarTHnSparse,G__setup_memfuncTHnSparse);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TF1),sizeof(TF1),-1,130816,"The Parametric 1-D function",G__setup_memvarTF1,G__setup_memfuncTF1);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TF2),sizeof(TF2),-1,130816,"The Parametric 2-D function",G__setup_memvarTF2,G__setup_memfuncTF2);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TGraph),sizeof(TGraph),-1,130816,"Graph graphics class",G__setup_memvarTGraph,G__setup_memfuncTGraph);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TGraphErrors),sizeof(TGraphErrors),-1,130816,"A graph with error bars",G__setup_memvarTGraphErrors,G__setup_memfuncTGraphErrors);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TGraph2D),sizeof(TGraph2D),-1,130816,"Set of n x[i],y[i],z[i] points with 3-d graphics including Delaunay triangulation",G__setup_memvarTGraph2D,G__setup_memfuncTGraph2D);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TMultiGraph),sizeof(TMultiGraph),-1,327424,"A collection of TGraph objects",G__setup_memvarTMultiGraph,G__setup_memfuncTMultiGraph);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TFitResult),sizeof(TFitResult),-1,324864,"Class holding the result of the fit ",G__setup_memvarTFitResult,G__setup_memfuncTFitResult);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TFitResultPtr),sizeof(TFitResultPtr),-1,298752,"indirection to TFitResult",G__setup_memvarTFitResultPtr,G__setup_memfuncTFitResultPtr);
   G__get_linked_tagnum_fwd(&G__G__HistLN_ROOTcLcLMath);
   G__get_linked_tagnum_fwd(&G__G__HistLN_ROOTcLcLMathcLcLMinimizerOptions);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_ROOTcLcLFit),0,-1,0,(char*)NULL,G__setup_memvarROOTcLcLFit,G__setup_memfuncROOTcLcLFit);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_ROOTcLcLFitcLcLFitResult),sizeof(ROOT::Fit::FitResult),-1,36608,(char*)NULL,NULL,G__setup_memfuncROOTcLcLFitcLcLFitResult);
   G__get_linked_tagnum_fwd(&G__G__HistLN_ROOTcLcLFitcLcLBinData);
   G__get_linked_tagnum_fwd(&G__G__HistLN_ROOTcLcLFitcLcLUnBinData);
   G__get_linked_tagnum_fwd(&G__G__HistLN_ROOTcLcLFitcLcLSparseData);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TAttAxis);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TArray);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TArrayD);
   G__get_linked_tagnum_fwd(&G__G__HistLN_THashList);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TAxis),sizeof(TAxis),-1,130816,"Axis class",G__setup_memvarTAxis,G__setup_memfuncTAxis);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TAxiscLcLdA);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TMethodCall);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TVirtualFitter);
   G__get_linked_tagnum_fwd(&G__G__HistLN_ROOTcLcLMathcLcLIBaseFunctionOneDim);
   G__get_linked_tagnum_fwd(&G__G__HistLN_ROOTcLcLMathcLcLIBaseFunctionMultiDim);
   G__get_linked_tagnum_fwd(&G__G__HistLN_ROOTcLcLMathcLcLIParametricFunctionOneDim);
   G__get_linked_tagnum_fwd(&G__G__HistLN_ROOTcLcLMathcLcLIParametricGradFunctionOneDim);
   G__get_linked_tagnum_fwd(&G__G__HistLN_ROOTcLcLMathcLcLIParametricFunctionMultiDim);
   G__get_linked_tagnum_fwd(&G__G__HistLN_ROOTcLcLMathcLcLIParametricGradFunctionMultiDim);
   G__get_linked_tagnum_fwd(&G__G__HistLN_ROOTcLcLMathcLcLMinimizer);
   G__get_linked_tagnum_fwd(&G__G__HistLN_ROOTcLcLFitcLcLFitConfig);
   G__get_linked_tagnum_fwd(&G__G__HistLN_vectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__HistLN_reverse_iteratorlEvectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__HistLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__HistLN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__HistLN_vectorlEdoublecOallocatorlEdoublegRsPgR);
   G__get_linked_tagnum_fwd(&G__G__HistLN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__HistLN_pairlEdoublecOdoublegR);
   G__get_linked_tagnum_fwd(&G__G__HistLN_maplEunsignedsPintcOpairlEdoublecOdoublegRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcOpairlEdoublecOdoublegRsPgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__HistLN_vectorlEstringcOallocatorlEstringgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__HistLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__HistLN_auto_ptrlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR);
   G__get_linked_tagnum_fwd(&G__G__HistLN_vectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__HistLN_reverse_iteratorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__HistLN_vectorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRcOallocatorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__HistLN_reverse_iteratorlEvectorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRcOallocatorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRsPgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__HistLN_ROOTcLcLFitcLcLFitData);
   G__get_linked_tagnum_fwd(&G__G__HistLN_vectorlEconstsPdoublemUcOallocatorlEconstsPdoublemUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__HistLN_reverse_iteratorlEvectorlEconstsPdoublemUcOallocatorlEconstsPdoublemUgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TBackCompFitter),sizeof(TBackCompFitter),-1,324864,"Class providing backward compatibility for fitting by implementing the TVirtualFitter interface",G__setup_memvarTBackCompFitter,G__setup_memfuncTBackCompFitter);
   G__get_linked_tagnum_fwd(&G__G__HistLN_auto_ptrlEROOTcLcLFitcLcLFittergR);
   G__get_linked_tagnum_fwd(&G__G__HistLN_auto_ptrlEROOTcLcLFitcLcLFitDatagR);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TBackCompFittercLcLdA);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TBinomialEfficiencyFitter),sizeof(TBinomialEfficiencyFitter),-1,324864,"Binomial Fitter for the division of two histograms",G__setup_memvarTBinomialEfficiencyFitter,G__setup_memfuncTBinomialEfficiencyFitter);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TConfidenceLevel),sizeof(TConfidenceLevel),-1,324864,"output for TLimit functions",G__setup_memvarTConfidenceLevel,G__setup_memfuncTConfidenceLevel);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TAttLine);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TAttFill);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TAttMarker);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TCollection);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TGraphAsymmErrors),sizeof(TGraphAsymmErrors),-1,130816,"A graph with asymmetric error bars",G__setup_memvarTGraphAsymmErrors,G__setup_memfuncTGraphAsymmErrors);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TH2),sizeof(TH2),-1,128768,"2-Dim histogram base class",G__setup_memvarTH2,G__setup_memfuncTH2);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TEfficiency),sizeof(TEfficiency),-1,327424,"calculating efficiencies",G__setup_memvarTEfficiency,G__setup_memfuncTEfficiency);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TEfficiencycLcLEStatOption);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TEfficiencycLcLdA);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TBits);
   G__get_linked_tagnum_fwd(&G__G__HistLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TFormulaPrimitive),sizeof(TFormulaPrimitive),-1,326400,"The primitive formula ",G__setup_memvarTFormulaPrimitive,G__setup_memfuncTFormulaPrimitive);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TOperOffset);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TFormula),sizeof(TFormula),-1,130816,"The formula base class  f(x,y,z,par)",G__setup_memvarTFormula,G__setup_memfuncTFormula);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TFormulacLcLdA);
   G__get_linked_tagnum_fwd(&G__G__HistLN_ROOTcLcLMathcLcLParamFunctor);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TF1cLcLdA);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TF12),sizeof(TF12),-1,325376,"Projection of a TF2 along x or y",G__setup_memvarTF12,G__setup_memfuncTF12);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TF3),sizeof(TF3),-1,130816,"The Parametric 3-D function",G__setup_memvarTF3,G__setup_memfuncTF3);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TMatrixTBaselEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TMatrixTBaselEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TVectorTlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TVectorTlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TElementActionTlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TElementPosActionTlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TMatrixTSymlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TMatrixTlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TMatrixTRow_constlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TMatrixTRowlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TMatrixTColumn_constlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TMatrixTDiag_constlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TMatrixTFlat_constlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TMatrixTSub_constlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TMatrixTSparseRow_constlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TMatrixTSparselEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TMatrixTSparseDiag_constlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TMatrixTColumnlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TMatrixTDiaglEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TMatrixTFlatlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TMatrixTSublEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TMatrixTSparseRowlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TMatrixTSparseDiaglEdoublegR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TFractionFitter),sizeof(TFractionFitter),-1,324864,"Fits MC fractions to data histogram",G__setup_memvarTFractionFitter,G__setup_memfuncTFractionFitter);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TVirtualHistPainter),sizeof(TVirtualHistPainter),-1,292111,"Abstract interface for histogram painters",G__setup_memvarTVirtualHistPainter,G__setup_memfuncTVirtualHistPainter);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TH2D),sizeof(TH2D),-1,130816,"2-Dim histograms (one double per channel)",G__setup_memvarTH2D,G__setup_memfuncTH2D);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TGraph2DErrors),sizeof(TGraph2DErrors),-1,130816,"A 2D graph with error bars",G__setup_memvarTGraph2DErrors,G__setup_memfuncTGraph2DErrors);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TH1F),sizeof(TH1F),-1,327424,"1-Dim histograms (one float per channel)",G__setup_memvarTH1F,G__setup_memfuncTH1F);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TSpline),sizeof(TSpline),-1,130819,"Spline base class",G__setup_memvarTSpline,G__setup_memfuncTSpline);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TGraphcLcLdA);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TGraphBentErrors),sizeof(TGraphBentErrors),-1,325376,"A graph with bent, asymmetric error bars",G__setup_memvarTGraphBentErrors,G__setup_memfuncTGraphBentErrors);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TGraphDelaunay),sizeof(TGraphDelaunay),-1,327424,"Delaunay triangulation",G__setup_memvarTGraphDelaunay,G__setup_memfuncTGraphDelaunay);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TGraphSmooth),sizeof(TGraphSmooth),-1,327424,"Graph Smoother",G__setup_memvarTGraphSmooth,G__setup_memfuncTGraphSmooth);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TGraphTime),sizeof(TGraphTime),-1,325376,"An array of objects evolving with time",G__setup_memvarTGraphTime,G__setup_memfuncTGraphTime);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TArrayC);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TArrayS);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TArrayI);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TArrayF);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TH1D),sizeof(TH1D),-1,327424,"1-Dim histograms (one double per channel)",G__setup_memvarTH1D,G__setup_memfuncTH1D);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TVirtualFFT);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TH1cLcLdA);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TH1C),sizeof(TH1C),-1,327424,"1-Dim histograms (one char per channel)",G__setup_memvarTH1C,G__setup_memfuncTH1C);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TH1S),sizeof(TH1S),-1,327424,"1-Dim histograms (one short per channel)",G__setup_memvarTH1S,G__setup_memfuncTH1S);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TH1I),sizeof(TH1I),-1,327424,"1-Dim histograms (one 32 bits integer per channel)",G__setup_memvarTH1I,G__setup_memfuncTH1I);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TH1K),sizeof(TH1K),-1,324864,"1-Dim Nearest Kth neighbour method",G__setup_memvarTH1K,G__setup_memfuncTH1K);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TProfile),sizeof(TProfile),-1,128768,"Profile histogram class",G__setup_memvarTProfile,G__setup_memfuncTProfile);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TH2C),sizeof(TH2C),-1,130816,"2-Dim histograms (one char per channel)",G__setup_memvarTH2C,G__setup_memfuncTH2C);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TH2S),sizeof(TH2S),-1,130816,"2-Dim histograms (one short per channel)",G__setup_memvarTH2S,G__setup_memfuncTH2S);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TH2I),sizeof(TH2I),-1,327424,"2-Dim histograms (one 32 bits integer per channel)",G__setup_memvarTH2I,G__setup_memfuncTH2I);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TH2F),sizeof(TH2F),-1,130816,"2-Dim histograms (one float per channel)",G__setup_memvarTH2F,G__setup_memfuncTH2F);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TH2PolyBin),sizeof(TH2PolyBin),-1,324864,"2-Dim polygon bins",G__setup_memvarTH2PolyBin,G__setup_memfuncTH2PolyBin);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TH2Poly),sizeof(TH2Poly),-1,324864,"2-Dim histogram with polygon bins",G__setup_memvarTH2Poly,G__setup_memfuncTH2Poly);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TAtt3D);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TProfile2D),sizeof(TProfile2D),-1,128768,"Profile2D histogram class",G__setup_memvarTProfile2D,G__setup_memfuncTProfile2D);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TH3),sizeof(TH3),-1,128768,"3-Dim histogram base class",G__setup_memvarTH3,G__setup_memfuncTH3);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TH3C),sizeof(TH3C),-1,130816,"3-Dim histograms (one char per channel)",G__setup_memvarTH3C,G__setup_memfuncTH3C);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TH3S),sizeof(TH3S),-1,130816,"3-Dim histograms (one short per channel)",G__setup_memvarTH3S,G__setup_memfuncTH3S);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TH3I),sizeof(TH3I),-1,327424,"3-Dim histograms (one 32 bits integer per channel)",G__setup_memvarTH3I,G__setup_memfuncTH3I);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TH3F),sizeof(TH3F),-1,130816,"3-Dim histograms (one float per channel)",G__setup_memvarTH3F,G__setup_memfuncTH3F);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TH3D),sizeof(TH3D),-1,130816,"3-Dim histograms (one double per channel)",G__setup_memvarTH3D,G__setup_memfuncTH3D);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_THLimitsFinder),sizeof(THLimitsFinder),-1,292096,"Class to find best axis limits",G__setup_memvarTHLimitsFinder,G__setup_memfuncTHLimitsFinder);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TExMap);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_THnSparseArrayChunk),sizeof(THnSparseArrayChunk),-1,327424,"chunks of linearized bins",G__setup_memvarTHnSparseArrayChunk,G__setup_memfuncTHnSparseArrayChunk);
   G__get_linked_tagnum_fwd(&G__G__HistLN_THnSparseCompactBinCoord);
   G__get_linked_tagnum_fwd(&G__G__HistLN_THnSparsecLcLdA);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_THnSparseTlETArrayDgR),sizeof(THnSparseT<TArrayD>),-1,323840,"Sparse n-dimensional histogram with templated content",G__setup_memvarTHnSparseTlETArrayDgR,G__setup_memfuncTHnSparseTlETArrayDgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_THnSparseTlETArrayFgR),sizeof(THnSparseT<TArrayF>),-1,323840,"Sparse n-dimensional histogram with templated content",G__setup_memvarTHnSparseTlETArrayFgR,G__setup_memfuncTHnSparseTlETArrayFgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_THnSparseTlETArrayLgR),sizeof(THnSparseT<TArrayL>),-1,323840,"Sparse n-dimensional histogram with templated content",G__setup_memvarTHnSparseTlETArrayLgR,G__setup_memfuncTHnSparseTlETArrayLgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_THnSparseTlETArrayIgR),sizeof(THnSparseT<TArrayI>),-1,323840,"Sparse n-dimensional histogram with templated content",G__setup_memvarTHnSparseTlETArrayIgR,G__setup_memfuncTHnSparseTlETArrayIgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_THnSparseTlETArraySgR),sizeof(THnSparseT<TArrayS>),-1,323840,"Sparse n-dimensional histogram with templated content",G__setup_memvarTHnSparseTlETArraySgR,G__setup_memfuncTHnSparseTlETArraySgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_THnSparseTlETArrayCgR),sizeof(THnSparseT<TArrayC>),-1,323840,"Sparse n-dimensional histogram with templated content",G__setup_memvarTHnSparseTlETArrayCgR,G__setup_memfuncTHnSparseTlETArrayCgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_THStack),sizeof(THStack),-1,327424,"A collection of histograms",G__setup_memvarTHStack,G__setup_memfuncTHStack);
   G__get_linked_tagnum_fwd(&G__G__HistLN_ROOTcLcLMathcLcLIGradientOneDim);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TKDE),sizeof(TKDE),-1,327424,"One dimensional semi-parametric Kernel Density Estimation",G__setup_memvarTKDE,G__setup_memfuncTKDE);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TKDEcLcLEKernelType);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TKDEcLcLEIteration);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TKDEcLcLEMirror);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TKDEcLcLEBinning);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TKDEcLcLTKernel);
   G__get_linked_tagnum_fwd(&G__G__HistLN_vectorlEboolcOallocatorlEboolgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__HistLN_reverse_iteratorlEvectorlEboolcOallocatorlEboolgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TLimitDataSource),sizeof(TLimitDataSource),-1,324864,"input for TLimit routines",G__setup_memvarTLimitDataSource,G__setup_memfuncTLimitDataSource);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TRandom);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TOrdCollection);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TLimit),sizeof(TLimit),-1,263424,"Class to compute 95% CL limits",G__setup_memvarTLimit,G__setup_memfuncTLimit);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TMultiDimFit),sizeof(TMultiDimFit),-1,324864,"Multi dimensional fit class",G__setup_memvarTMultiDimFit,G__setup_memfuncTMultiDimFit);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TMultiDimFitcLcLEMDFPolyType);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TPolyMarker),sizeof(TPolyMarker),-1,130816,"An array of points with the same marker",G__setup_memvarTPolyMarker,G__setup_memfuncTPolyMarker);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TPrincipal),sizeof(TPrincipal),-1,327424,"Principal Components Analysis",G__setup_memvarTPrincipal,G__setup_memfuncTPrincipal);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_EErrorType),sizeof(int),-1,0,(char*)NULL,NULL,NULL);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TProfile3D),sizeof(TProfile3D),-1,325376,"Profile3D histogram class",G__setup_memvarTProfile3D,G__setup_memfuncTProfile3D);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TSplinePoly),sizeof(TSplinePoly),-1,326400,"Spline polynomial terms",G__setup_memvarTSplinePoly,G__setup_memfuncTSplinePoly);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TSplinePoly3),sizeof(TSplinePoly3),-1,326400,"Third spline polynomial terms",G__setup_memvarTSplinePoly3,G__setup_memfuncTSplinePoly3);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TSplinePoly5),sizeof(TSplinePoly5),-1,326400,"Quintic spline polynomial terms",G__setup_memvarTSplinePoly5,G__setup_memfuncTSplinePoly5);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TSpline3),sizeof(TSpline3),-1,130816,"Class to create third natural splines",G__setup_memvarTSpline3,G__setup_memfuncTSpline3);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TSpline5),sizeof(TSpline5),-1,130816,"Class to create quintic natural splines",G__setup_memvarTSpline5,G__setup_memfuncTSpline5);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TSVDUnfold),sizeof(TSVDUnfold),-1,325120,"Data unfolding using Singular Value Decomposition (hep-ph/9509307)   ",G__setup_memvarTSVDUnfold,G__setup_memfuncTSVDUnfold);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TUnfold),sizeof(TUnfold),-1,324864,"Unfolding with support for L-curve analysis",G__setup_memvarTUnfold,G__setup_memfuncTUnfold);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TUnfoldcLcLEConstraint);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TUnfoldcLcLERegMode);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TUnfoldcLcLEHistMap);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TMap);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TUnfoldSys),sizeof(TUnfoldSys),-1,324864,"Unfolding with support for systematic error propagation",G__setup_memvarTUnfoldSys,G__setup_memfuncTUnfoldSys);
   G__get_linked_tagnum_fwd(&G__G__HistLN_TUnfoldSyscLcLESysErrMode);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_TVirtualGraphPainter),sizeof(TVirtualGraphPainter),-1,292104,"Abstract interface for histogram painters",G__setup_memvarTVirtualGraphPainter,G__setup_memfuncTVirtualGraphPainter);
   G__get_linked_tagnum_fwd(&G__G__HistLN_ROOTcLcLMathcLcLIBaseParam);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_ROOTcLcLMathcLcLWrappedMultiTF1),sizeof(ROOT::Math::WrappedMultiTF1),-1,36352,(char*)NULL,G__setup_memvarROOTcLcLMathcLcLWrappedMultiTF1,G__setup_memfuncROOTcLcLMathcLcLWrappedMultiTF1);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__HistLN_ROOTcLcLMathcLcLWrappedTF1),sizeof(ROOT::Math::WrappedTF1),-1,36352,(char*)NULL,G__setup_memvarROOTcLcLMathcLcLWrappedTF1,G__setup_memfuncROOTcLcLMathcLcLWrappedTF1);
}
extern "C" void G__cpp_setupG__Hist(void) {
  G__check_setup_version(30051515,"G__cpp_setupG__Hist()");
  G__set_cpp_environmentG__Hist();
  G__cpp_setup_tagtableG__Hist();

  G__cpp_setup_inheritanceG__Hist();

  G__cpp_setup_typetableG__Hist();

  G__cpp_setup_memvarG__Hist();

  G__cpp_setup_memfuncG__Hist();
  G__cpp_setup_globalG__Hist();
  G__cpp_setup_funcG__Hist();

   if(0==G__getsizep2memfunc()) G__get_sizep2memfuncG__Hist();
  return;
}
class G__cpp_setup_initG__Hist {
  public:
    G__cpp_setup_initG__Hist() { G__add_setup_func("G__Hist",(G__incsetup)(&G__cpp_setupG__Hist)); G__call_setup_funcs(); }
   ~G__cpp_setup_initG__Hist() { G__remove_setup_func("G__Hist"); }
};
G__cpp_setup_initG__Hist G__cpp_setup_initializerG__Hist;

---