ROOT logo
// @(#)root/meta:$Id: TClass.cxx 31472 2009-11-30 17:59:33Z pcanal $
// Author: Rene Brun   07/01/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/

//////////////////////////////////////////////////////////////////////////
//                                                                      //
//  The ROOT global object gROOT contains a list of all defined         //
//  classes. This list is build when a reference to a class dictionary  //
//  is made. When this happens, the static "class"::Dictionary()        //
//  function is called to create a TClass object describing the         //
//  class. The Dictionary() function is defined in the ClassDef         //
//  macro and stored (at program startup or library load time) together //
//  with the class name in the TClassTable singleton object.            //
//  For a description of all dictionary classes see TDictionary.        //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

//*-*x7.5 macros/layout_class

#include "TClass.h"

#include "Riostream.h"
#include "TBaseClass.h"
#include "TBrowser.h"
#include "TBuffer.h"
#include "TClassGenerator.h"
#include "TClassEdit.h"
#include "TClassMenuItem.h"
#include "TClassRef.h"
#include "TClassTable.h"
#include "TDataMember.h"
#include "TDataType.h"
#include "TError.h"
#include "TExMap.h"
#include "THashList.h"
#include "TInterpreter.h"
#include "TMemberInspector.h"
#include "TMethod.h"
#include "TMethodArg.h"
#include "TMethodCall.h"
#include "TObjArray.h"
#include "TROOT.h"
#include "TRealData.h"
#include "TStreamer.h"
#include "TStreamerElement.h"
#include "TVirtualStreamerInfo.h"
#include "TVirtualCollectionProxy.h"
#include "TVirtualIsAProxy.h"
#include "TVirtualRefProxy.h"
#include "TVirtualMutex.h"
#include "TVirtualPad.h"
#include "THashTable.h"
#include "TSchemaRuleSet.h"
#include "TGenericClassInfo.h"
#include "TIsAProxy.h"

#include <cstdio>
#include <cctype>
#include <set>
#include <sstream>
#include <string>
#include <map>
#include <typeinfo>
#include <cmath>
#include <assert.h>

using namespace std;

// Mutex to protect CINT operations
// (exported to be used for similar cases in related classes)

TVirtualMutex* gCINTMutex = 0;

void *gMmallocDesc = 0; //is used and set in TMapFile

Int_t TClass::fgClassCount;
TClass::ENewType TClass::fgCallingNew = kRealNew;

static std::multimap<void*, Version_t> gObjectVersionRepository;

static void RegisterAddressInRepository(const char * /*where*/, void *location, const TClass *what)
{
   // Register the object for special handling in the destructor.

   Version_t version = what->GetClassVersion();
//    if (!gObjectVersionRepository.count(location)) {
//       Info(where, "Registering address %p of class '%s' version %d", location, what->GetName(), version);
//    } else {
//       Warning(where, "Registering address %p again of class '%s' version %d", location, what->GetName(), version);
//    }
   gObjectVersionRepository.insert(std::pair<void* const,Version_t>(location, version));

#if 0
   // This code could be used to prevent an address to be registered twice.
   std::pair<std::map<void*, Version_t>::iterator, Bool_t> tmp = gObjectVersionRepository.insert(std::pair<void*,Version_t>(location, version));
   if (!tmp.second) {
      Warning(where, "Reregistering an object of class '%s' version %d at address %p", what->GetName(), version, p);
      gObjectVersionRepository.erase(tmp.first);
      tmp = gObjectVersionRepository.insert(std::pair<void*,Version_t>(location, version));
      if (!tmp.second) {
         Warning(where, "Failed to reregister an object of class '%s' version %d at address %p", what->GetName(), version, location);
      }
   }
#endif
}

static void UnregisterAddressInRepository(const char * /*where*/, void *location, const TClass *what)
{
   std::multimap<void*, Version_t>::iterator cur = gObjectVersionRepository.find(location);
   for (; cur != gObjectVersionRepository.end();) {
      std::multimap<void*, Version_t>::iterator tmp = cur++;
      if ((tmp->first == location) && (tmp->second == what->GetClassVersion())) {
         // -- We still have an address, version match.
         // Info(where, "Unregistering address %p of class '%s' version %d", location, what->GetName(), what->GetClassVersion());
         gObjectVersionRepository.erase(tmp);
      } else {
         // -- No address, version match, we've reached the end.
         break;
      }
   }
}

static void MoveAddressInRepository(const char *where, void *oldadd, void *newadd, const TClass *what)
{
   UnregisterAddressInRepository(where,oldadd,what);
   RegisterAddressInRepository(where,newadd,what);
}

//______________________________________________________________________________
//______________________________________________________________________________
namespace ROOT {
#define R__USE_STD_MAP
   class TMapTypeToTClass {
#if defined R__USE_STD_MAP
     // This wrapper class allow to avoid putting #include <map> in the
     // TROOT.h header file.
   public:
#ifdef R__GLOBALSTL
      typedef map<string,TClass*>                 IdMap_t;
#else
      typedef std::map<std::string,TClass*>       IdMap_t;
#endif
      typedef IdMap_t::key_type                   key_type;
      typedef IdMap_t::const_iterator             const_iterator;
      typedef IdMap_t::size_type                  size_type;
#ifdef R__WIN32
     // Window's std::map does NOT defined mapped_type
      typedef TClass*                             mapped_type;
#else
      typedef IdMap_t::mapped_type                mapped_type;
#endif

   private:
      IdMap_t fMap;

   public:
      void Add(const key_type &key, mapped_type &obj) {
         fMap[key] = obj;
      }
      mapped_type Find(const key_type &key) const {
         IdMap_t::const_iterator iter = fMap.find(key);
         mapped_type cl = 0;
         if (iter != fMap.end()) cl = iter->second;
         return cl;
      }
      void Remove(const key_type &key) { fMap.erase(key); }
#else
   private:
      TMap fMap;

   public:
      void Add(const char *key, TClass *&obj) {
         TObjString *realkey = new TObjString(key);
         fMap.Add(realkey, obj);
      }
      TClass* Find(const char *key) const {
         const TPair *a = (const TPair *)fMap.FindObject(key);
         if (a) return (TClass*) a->Value();
         return 0;
      }
      void Remove(const char *key) {
         TObjString realkey(key);
         TObject *actual = fMap.Remove(&realkey);
         delete actual;
      }
#endif
   };
}
IdMap_t *TClass::fgIdMap = new IdMap_t;

//______________________________________________________________________________
void TClass::AddClass(TClass *cl)
{
   // static: Add a class to the list and map of classes.

   if (!cl) return;
   gROOT->GetListOfClasses()->Add(cl);
   if (cl->GetTypeInfo()) {
      fgIdMap->Add(cl->GetTypeInfo()->name(),cl);
   }
}


//______________________________________________________________________________
void TClass::RemoveClass(TClass *oldcl)
{
   // static: Remove a class from the list and map of classes

   if (!oldcl) return;
   gROOT->GetListOfClasses()->Remove(oldcl);
   if (oldcl->GetTypeInfo()) {
      fgIdMap->Remove(oldcl->GetTypeInfo()->name());
   }
}

//______________________________________________________________________________
//______________________________________________________________________________

class TDumpMembers : public TMemberInspector {

public:
   TDumpMembers() { }
   void Inspect(TClass *cl, const char *parent, const char *name, const void *addr);
};

//______________________________________________________________________________
void TDumpMembers::Inspect(TClass *cl, const char *pname, const char *mname, const void *add)
{
   // Print value of member mname.
   //
   // This method is called by the ShowMembers() method for each
   // data member when object.Dump() is invoked.
   //
   //    cl    is the pointer to the current class
   //    pname is the parent name (in case of composed objects)
   //    mname is the data member name
   //    add   is the data member address

   const Int_t kvalue = 30;
#ifdef R__B64
   const Int_t ktitle = 50;
#else
   const Int_t ktitle = 42;
#endif
   const Int_t kline  = 1024;
   Int_t cdate = 0;
   Int_t ctime = 0;
   UInt_t *cdatime = 0;
   char line[kline];

   TDataType *membertype;
   TString memberTypeName;
   const char *memberName;
   const char *memberFullTypeName;
   const char *memberTitle;
   Bool_t isapointer;
   Bool_t isbasic;

   if (TDataMember *member = cl->GetDataMember(mname)) {
      memberTypeName = member->GetTypeName();
      memberName = member->GetName();
      memberFullTypeName = member->GetFullTypeName();
      memberTitle = member->GetTitle();
      isapointer = member->IsaPointer();
      isbasic = member->IsBasic();
      membertype = member->GetDataType();
   } else if (!cl->IsLoaded()) {
      // The class is not loaded, hence it is 'emulated' and the main source of
      // information is the StreamerInfo.
      TVirtualStreamerInfo *info = cl->GetStreamerInfo();
      if (!info) return;
      const char *cursor = mname;
      while ( (*cursor)=='*' ) ++cursor;
      TString elname( cursor );
      Ssiz_t pos = elname.Index("[");
      if ( pos != kNPOS ) {
         elname.Remove( pos );
      }
      TStreamerElement *element = (TStreamerElement*)info->GetElements()->FindObject(elname.Data());
      memberFullTypeName = element->GetTypeName();
      
      memberTypeName = memberFullTypeName;
      memberTypeName = memberTypeName.Strip(TString::kTrailing, '*');
      if (memberTypeName.Index("const ")==0) memberTypeName.Remove(0,6);

      memberName = element->GetName();
      memberTitle = element->GetTitle();
      isapointer = element->IsaPointer() || element->GetType() == TVirtualStreamerInfo::kCharStar;
      membertype = gROOT->GetType(memberFullTypeName);
      
      isbasic = membertype !=0;
   } else {
      return;
   }
   
   
   Bool_t isdate = kFALSE;
   if (strcmp(memberName,"fDatime") == 0 && strcmp(memberTypeName,"UInt_t") == 0) {
      isdate = kTRUE;
   }
   Bool_t isbits = kFALSE;
   if (strcmp(memberName,"fBits") == 0 && strcmp(memberTypeName,"UInt_t") == 0) {
      isbits = kTRUE;
   }

   Int_t i;
   for (i = 0;i < kline; i++) line[i] = ' ';
   line[kline-1] = 0;
   sprintf(line,"%s%s ",pname,mname);
   i = strlen(line); line[i] = ' ';

   // Encode data value or pointer value
   char *pointer = (char*)add;
   char **ppointer = (char**)(pointer);

   if (isapointer) {
      char **p3pointer = (char**)(*ppointer);
      if (!p3pointer)
         sprintf(&line[kvalue],"->0");
      else if (!isbasic)
         sprintf(&line[kvalue],"->%lx ", (Long_t)p3pointer);
      else if (membertype) {
         if (!strcmp(membertype->GetTypeName(), "char")) {
            i = strlen(*ppointer);
            if (kvalue+i >= kline) i=kline-kvalue;
            Bool_t isPrintable = kTRUE;
            for (Int_t j = 0; j < i; j++) {
               if (!std::isprint((*ppointer)[j])) {
                  isPrintable = kFALSE;
                  break;
               }
            }
            if (isPrintable) {
               strncpy(line + kvalue, *ppointer, i);
               line[kvalue+i] = 0;
            } else {
               line[kvalue] = 0;
            }
         } else {
            strcpy(&line[kvalue], membertype->AsString(p3pointer));
         }
      } else if (!strcmp(memberFullTypeName, "char*") ||
                 !strcmp(memberFullTypeName, "const char*")) {
         i = strlen(*ppointer);
         if (kvalue+i >= kline) i=kline-kvalue;
         Bool_t isPrintable = kTRUE;
         for (Int_t j = 0; j < i; j++) {
            if (!std::isprint((*ppointer)[j])) {
               isPrintable = kFALSE;
               break;
            }
         }
         if (isPrintable) {
            strncpy(line + kvalue, *ppointer, i);
            line[kvalue+i] = 0;
         } else {
            line[kvalue] = 0;
         }
      } else {
         sprintf(&line[kvalue],"->%lx ", (Long_t)p3pointer);
      }
   } else if (membertype)
      if (isdate) {
         cdatime = (UInt_t*)pointer;
         TDatime::GetDateTime(cdatime[0],cdate,ctime);
         sprintf(&line[kvalue],"%d/%d",cdate,ctime);
      } else if (isbits) {
         sprintf(&line[kvalue],"0x%08x", *(UInt_t*)pointer);
      } else {
         strcpy(&line[kvalue], membertype->AsString(pointer));
      }
   else
      sprintf(&line[kvalue],"->%lx ", (Long_t)pointer);

   // Encode data member title
   if (isdate == kFALSE && strcmp(memberFullTypeName, "char*") && strcmp(memberFullTypeName, "const char*")) {
      i = strlen(&line[0]); line[i] = ' ';
      Int_t lentit = strlen(memberTitle);
      if (lentit > 250-ktitle) lentit = 250-ktitle;
      strncpy(&line[ktitle],memberTitle,lentit);
      line[ktitle+lentit] = 0;
   }
   Printf("%s", line);
}

THashTable* TClass::fgClassTypedefHash = 0;
THashTable* TClass::fgClassShortTypedefHash = 0;

//______________________________________________________________________________
//______________________________________________________________________________
//______________________________________________________________________________
TClass::TNameMapNode::TNameMapNode (const char* typedf, const char* orig)
  : TObjString (typedf),
    fOrigName (orig)
{
}

//______________________________________________________________________________

class TBuildRealData : public TMemberInspector {

private:
   void    *fRealDataObject;
   TClass  *fRealDataClass;
   UInt_t   fBits;       //bit field status word

public:
   TBuildRealData(void *obj, TClass *cl) : fBits(0) {
      fRealDataObject = obj;
      fRealDataClass = cl;
   }
   void Inspect(TClass *cl, const char *parent, const char *name, const void *addr);

   //----- bit manipulation
   void     SetBit(UInt_t f, Bool_t set);
   void     SetBit(UInt_t f) { fBits |= f & TObject::kBitMask; }
   void     ResetBit(UInt_t f) { fBits &= ~(f & TObject::kBitMask); }
   Bool_t   TestBit(UInt_t f) const { return (Bool_t) ((fBits & f) != 0); }
   Int_t    TestBits(UInt_t f) const { return (Int_t) (fBits & f); }
   void     InvertBit(UInt_t f) { fBits ^= f & TObject::kBitMask; }
};

//______________________________________________________________________________
void TBuildRealData::Inspect(TClass* cl, const char* pname, const char* mname, const void* add)
{
   // This method is called from ShowMembers() via BuildRealdata().

   TDataMember* dm = cl->GetDataMember(mname);
   if (!dm) {
      return;
   }

   Bool_t isTransient = kFALSE;

   if (!dm->IsPersistent()) {
      // For the DataModelEvolution we need access to the transient member.
      // so we now record them in the list of RealData.
      isTransient = kTRUE;
   }

   char rname[512];
   strcpy(rname, pname);
   // Take into account cases like TPaveStats->TPaveText->TPave->TBox.
   // Check that member is in a derived class or an object in the class.
   if (cl != fRealDataClass) {
      if (!fRealDataClass->InheritsFrom(cl)) {
         char* dot = strchr(rname, '.');
         if (!dot) {
            return;
         }
         *dot = 0;
         if (!fRealDataClass->GetDataMember(rname)) {
            //could be a data member in a base class like in this example
            // class Event : public Data {
            //   class Data : public TObject {
            //     EventHeader fEvtHdr;
            //     class EventHeader {
            //       Int_t     fEvtNum;
            //       Int_t     fRun;
            //       Int_t     fDate;
            //       EventVertex fVertex;
            //       class EventVertex {
            //         EventTime  fTime;
            //         class EventTime {
            //           Int_t     fSec;
            //           Int_t     fNanoSec;
            if (!fRealDataClass->GetBaseDataMember(rname)) {
               return;
            }
         }
         *dot = '.';
      }
   }
   strcat(rname, mname);
   Long_t offset = Long_t(((Long_t) add) - ((Long_t) fRealDataObject));

   if (dm->IsaPointer()) {
      // Data member is a pointer.
      if (!dm->IsBasic()) {
         // Pointer to class object.
         TRealData* rd = new TRealData(rname, offset, dm);
         if (isTransient) { rd->SetBit(TRealData::kTransient); };
         fRealDataClass->GetListOfRealData()->Add(rd);
      } else {
         // Pointer to basic data type.
         TRealData* rd = new TRealData(rname, offset, dm);
         if (isTransient) { rd->SetBit(TRealData::kTransient); };
         fRealDataClass->GetListOfRealData()->Add(rd);
      }
   } else {
      // Data Member is a basic data type.
      TRealData* rd = new TRealData(rname, offset, dm);
      if (isTransient) { rd->SetBit(TRealData::kTransient); };
      if (!dm->IsBasic()) {
         rd->SetIsObject(kTRUE);

         // Make sure that BuildReadData is called for any abstract
         // bases classes involved in this object, i.e for all the
         // classes composing this object (base classes, type of
         // embedded object and same for their data members).
         //
         TClass* dmclass = TClass::GetClass(dm->GetTypeName(), kTRUE, isTransient || TestBit(TRealData::kTransient));
         if (!dmclass) {
            dmclass = TClass::GetClass(dm->GetTrueTypeName(), kTRUE, isTransient || TestBit(TRealData::kTransient));
         }
         if (dmclass) {
            if (dmclass->Property()) {
               if (dmclass->Property() & kIsAbstract) {
                  fprintf(stderr, "TBuildRealDataRecursive::Inspect(): data member class: '%s'  is abstract.\n", dmclass->GetName());
               }
            }
            if ((dmclass != cl) && !dm->IsaPointer()) {
               if (dmclass->GetCollectionProxy()) {
                  TClass* valcl = dmclass->GetCollectionProxy()->GetValueClass();
                  if (valcl && !(valcl->Property() & kIsAbstract)) valcl->BuildRealData(0, isTransient || TestBit(TRealData::kTransient));
               } else {
                  dmclass->BuildRealData(const_cast<void*>(add), isTransient || TestBit(TRealData::kTransient));
               }
            }
         }
      }
      fRealDataClass->GetListOfRealData()->Add(rd);
   }
}

//______________________________________________________________________________
//______________________________________________________________________________
//______________________________________________________________________________

//______________________________________________________________________________
class TAutoInspector : public TMemberInspector {

public:
   Int_t     fCount;
   TBrowser *fBrowser;

   TAutoInspector(TBrowser *b) { fBrowser = b; fCount = 0; }
   virtual ~TAutoInspector() { }
   virtual void Inspect(TClass *cl, const char *parent, const char *name, const void *addr);
};

//______________________________________________________________________________
void TAutoInspector::Inspect(TClass *cl, const char *tit, const char *name,
                             const void *addr)
{
   // This method is called from ShowMembers() via AutoBrowse().

   if(tit && strchr(tit,'.'))    return ;
   if (fCount && !fBrowser) return;

   TString ts;

   if (!cl) return;
   //if (*(cl->GetName()) == 'T') return;
   if (*name == '*') name++;
   int ln = strcspn(name,"[ ");
   TString iname(name,ln);

   ClassInfo_t *classInfo = cl->GetClassInfo();
   if (!classInfo)               return;

   //              Browse data members
   DataMemberInfo_t *m = gCint->DataMemberInfo_Factory(classInfo);
   TString mname;

   int found=0;
   while (gCint->DataMemberInfo_Next(m)) {    // MemberLoop
      mname = gCint->DataMemberInfo_Name(m);
      mname.ReplaceAll("*","");
      if ((found = (iname==mname))) break;
   }
   assert(found);

   // we skip: non static members and non objects
   //  - the member G__virtualinfo inserted by the CINT RTTI system

   //Long_t prop = m.Property() | m.Type()->Property();
   Long_t prop = gCint->DataMemberInfo_Property(m) | gCint->DataMemberInfo_TypeProperty(m);
   if (prop & G__BIT_ISSTATIC)           return;
   if (prop & G__BIT_ISFUNDAMENTAL)      return;
   if (prop & G__BIT_ISENUM)             return;
   if (mname == "G__virtualinfo")        return;

   int  size = sizeof(void*);

   int nmax = 1;
   if (prop & G__BIT_ISARRAY) {
      for (int dim = 0; dim < gCint->DataMemberInfo_ArrayDim(m); dim++) nmax *= gCint->DataMemberInfo_MaxIndex(m,dim);
   }

   std::string clmName(TClassEdit::ShortType(gCint->DataMemberInfo_TypeName(m),
                                             TClassEdit::kDropTrailStar) );
   TClass * clm = TClass::GetClass(clmName.c_str());
   R__ASSERT(clm);
   if (!(prop&G__BIT_ISPOINTER)) {
      size = clm->Size();
      if (size==0) size = gCint->DataMemberInfo_TypeSize(m);
   }


   gCint->DataMemberInfo_Delete(m);
   TVirtualCollectionProxy *proxy = clm->GetCollectionProxy();

   for(int i=0; i<nmax; i++) {

      char *ptr = (char*)addr + i*size;

      void *obj = (prop&G__BIT_ISPOINTER) ? *((void**)ptr) : (TObject*)ptr;

      if (!obj)           continue;

      fCount++;
      if (!fBrowser)      return;

      TString bwname;
      TClass *actualClass = clm->GetActualClass(obj);
      if (clm->IsTObject()) {
         TObject *tobj = (TObject*)clm->DynamicCast(TObject::Class(),obj);
         bwname = tobj->GetName();
      } else {
         bwname = actualClass->GetName();
         bwname += "::";
         bwname += mname;
      }

      if (!clm->IsTObject() ||
          bwname.Length()==0 ||
          strcmp(bwname.Data(),actualClass->GetName())==0) {
         bwname = name;
         int l = strcspn(bwname.Data(),"[ ");
         if (l<bwname.Length() && bwname[l]=='[') {
            char cbuf[12]; sprintf(cbuf,"[%02d]",i);
            ts.Replace(0,999,bwname,l);
            ts += cbuf;
            bwname = (const char*)ts;
         }
      }

      if (proxy==0) {

         fBrowser->Add(obj,clm,bwname);

      } else {
         TClass *valueCl = proxy->GetValueClass();

         if (valueCl==0) {

            fBrowser->Add( obj, clm, bwname );

         } else {
            TVirtualCollectionProxy::TPushPop env(proxy, obj);
            TClass *actualCl = 0;

            int sz = proxy->Size();

            char fmt[] = {"#%09d"};
            fmt[3]  = '0'+(int)log10(double(sz))+1;
            char buf[20];
            for (int ii=0;ii<sz;ii++) {
               void *p = proxy->At(ii);

               if (proxy->HasPointers()) {
                  p = *((void**)p);
                  if(!p) continue;
                  actualCl = valueCl->GetActualClass(p);
                  p = actualCl->DynamicCast(valueCl,p,0);
               }
               fCount++;
               sprintf(buf,fmt,ii);
               ts = bwname;
               ts += buf;
               fBrowser->Add( p, actualCl, ts );
            }
         }
      }
   }
}

//______________________________________________________________________________
//______________________________________________________________________________
//______________________________________________________________________________

ClassImp(TClass)

//______________________________________________________________________________
TClass::TClass() :
   TDictionary(),
   fStreamerInfo(0), fConversionStreamerInfo(0), fRealData(0),
   fBase(0), fData(0), fMethod(0), fAllPubData(0), fAllPubMethod(0),
   fClassMenuList(0),
   fDeclFileName(""), fImplFileName(""), fDeclFileLine(0), fImplFileLine(0),
   fInstanceCount(0), fOnHeap(0),
   fCheckSum(0), fCollectionProxy(0), fClassVersion(0), fClassInfo(0),
   fTypeInfo(0), fShowMembers(0), fInterShowMembers(0),
   fStreamer(0), fIsA(0), fGlobalIsA(0), fIsAMethod(0),
   fNew(0), fNewArray(0), fDelete(0), fDeleteArray(0),
   fDestructor(0), fDirAutoAdd(0), fSizeof(-1),
   fVersionUsed(kFALSE), fProperty(0),
   fInterStreamer(0), fOffsetStreamer(0), fStreamerType(kNone),
   fCurrentInfo(0), fRefStart(0), fRefProxy(0),
   fSchemaRules(0)
{
   // Default ctor.

   fDeclFileLine   = -2;    // -2 for standalone TClass (checked in dtor)
}

//______________________________________________________________________________
TClass::TClass(const char *name, Bool_t silent) :
   TDictionary(name),
   fStreamerInfo(0), fConversionStreamerInfo(0), fRealData(0),
   fBase(0), fData(0), fMethod(0), fAllPubData(0), fAllPubMethod(0),
   fClassMenuList(0),
   fDeclFileName(""), fImplFileName(""), fDeclFileLine(0), fImplFileLine(0),
   fInstanceCount(0), fOnHeap(0),
   fCheckSum(0), fCollectionProxy(0), fClassVersion(0), fClassInfo(0),
   fTypeInfo(0), fShowMembers(0), fInterShowMembers(0),
   fStreamer(0), fIsA(0), fGlobalIsA(0), fIsAMethod(0),
   fNew(0), fNewArray(0), fDelete(0), fDeleteArray(0),
   fDestructor(0), fDirAutoAdd(0), fSizeof(-1),
   fVersionUsed(kFALSE), fProperty(0),
   fInterStreamer(0), fOffsetStreamer(0), fStreamerType(kNone),
   fCurrentInfo(0), fRefStart(0), fRefProxy(0),
   fSchemaRules(0)
{
   // Create a TClass object. This object contains the full dictionary
   // of a class. It has list to baseclasses, datamembers and methods.
   // Use this ctor to create a standalone TClass object. Most useful
   // to get a TClass interface to an interpreted class. Used by TTabCom.
   // Normally you would use TClass::GetClass("class") to get access to a
   // TClass object for a certain class.

   if (!gROOT)
      ::Fatal("TClass::TClass", "ROOT system not initialized");

   fDeclFileLine   = -2;    // -2 for standalone TClass (checked in dtor)

   SetBit(kLoading);
   if (!gInterpreter)
      ::Fatal("TClass::TClass", "gInterpreter not initialized");

   gInterpreter->SetClassInfo(this);   // sets fClassInfo pointer
   if (!fClassInfo) {
      gInterpreter->InitializeDictionaries();
      gInterpreter->SetClassInfo(this);
   }
   if (!silent && !fClassInfo && fName.First('@')==kNPOS) 
      ::Warning("TClass::TClass", "no dictionary for class %s is available", name);
   ResetBit(kLoading);

   if (fClassInfo) SetTitle(gCint->ClassInfo_Title(fClassInfo));
   fConversionStreamerInfo = 0;
}

//______________________________________________________________________________
TClass::TClass(const char *name, Version_t cversion,
               const char *dfil, const char *ifil, Int_t dl, Int_t il, Bool_t silent) :
   TDictionary(name),
   fStreamerInfo(0), fConversionStreamerInfo(0), fRealData(0),
   fBase(0), fData(0), fMethod(0), fAllPubData(0), fAllPubMethod(0),
   fClassMenuList(0),
   fDeclFileName(""), fImplFileName(""), fDeclFileLine(0), fImplFileLine(0),
   fInstanceCount(0), fOnHeap(0),
   fCheckSum(0), fCollectionProxy(0), fClassVersion(0), fClassInfo(0),
   fTypeInfo(0), fShowMembers(0), fInterShowMembers(0),
   fStreamer(0), fIsA(0), fGlobalIsA(0), fIsAMethod(0),
   fNew(0), fNewArray(0), fDelete(0), fDeleteArray(0),
   fDestructor(0), fDirAutoAdd(0), fSizeof(-1),
   fVersionUsed(kFALSE), fProperty(0),
   fInterStreamer(0), fOffsetStreamer(0), fStreamerType(kNone),
   fCurrentInfo(0), fRefStart(0), fRefProxy(0),
   fSchemaRules(0)
{
   // Create a TClass object. This object contains the full dictionary
   // of a class. It has list to baseclasses, datamembers and methods.
   Init(name,cversion, 0, 0, 0, dfil, ifil, dl, il,silent);
   SetBit(kUnloaded);
}

//______________________________________________________________________________
TClass::TClass(const char *name, Version_t cversion,
               const type_info &info, TVirtualIsAProxy *isa,
               ShowMembersFunc_t showmembers,
               const char *dfil, const char *ifil, Int_t dl, Int_t il,
               Bool_t silent) :
   TDictionary(name),
   fStreamerInfo(0), fConversionStreamerInfo(0), fRealData(0),
   fBase(0), fData(0), fMethod(0), fAllPubData(0), fAllPubMethod(0),
   fClassMenuList(0),
   fDeclFileName(""), fImplFileName(""), fDeclFileLine(0), fImplFileLine(0),
   fInstanceCount(0), fOnHeap(0),
   fCheckSum(0), fCollectionProxy(0), fClassVersion(0), fClassInfo(0),
   fTypeInfo(0), fShowMembers(0), fInterShowMembers(0),
   fStreamer(0), fIsA(0), fGlobalIsA(0), fIsAMethod(0),
   fNew(0), fNewArray(0), fDelete(0), fDeleteArray(0),
   fDestructor(0), fDirAutoAdd(0), fSizeof(-1),
   fVersionUsed(kFALSE), fProperty(0),
   fInterStreamer(0), fOffsetStreamer(0), fStreamerType(kNone),
   fCurrentInfo(0), fRefStart(0), fRefProxy(0),
   fSchemaRules(0)
{
   // Create a TClass object. This object contains the full dictionary
   // of a class. It has list to baseclasses, datamembers and methods.

   // use info
   Init(name, cversion, &info, isa, showmembers, dfil, ifil, dl, il, silent);
}

//______________________________________________________________________________
void TClass::ForceReload (TClass* oldcl)
{
   // we found at least one equivalent.
   // let's force a reload

   TClass::RemoveClass(oldcl);

   if (oldcl->CanIgnoreTObjectStreamer()) {
      IgnoreTObjectStreamer();
   }

   TVirtualStreamerInfo *info;
   TIter next(oldcl->GetStreamerInfos());
   while ((info = (TVirtualStreamerInfo*)next())) {
      info->Clear("build");
      info->SetClass(this);
      fStreamerInfo->AddAtAndExpand(info,info->GetClassVersion());
   }
   oldcl->GetStreamerInfos()->Clear();

   oldcl->ReplaceWith(this);
   delete oldcl;
}
//______________________________________________________________________________
void TClass::Init(const char *name, Version_t cversion,
                  const type_info *typeinfo, TVirtualIsAProxy *isa,
                  ShowMembersFunc_t showmembers,
                  const char *dfil, const char *ifil, Int_t dl, Int_t il,
                  Bool_t silent)
{
   // Initialize a TClass object. This object contains the full dictionary
   // of a class. It has list to baseclasses, datamembers and methods.
   if (!gROOT)
      ::Fatal("TClass::TClass", "ROOT system not initialized");

   SetName(name);
   fClassVersion   = cversion;
   fDeclFileName   = dfil ? dfil : "";
   fImplFileName   = ifil ? ifil : "";
   fDeclFileLine   = dl;
   fImplFileLine   = il;
   fTypeInfo       = typeinfo;
   fIsA            = isa;
   if ( fIsA ) fIsA->SetClass(this);
   fShowMembers    = showmembers;
   fStreamerInfo   = new TObjArray(fClassVersion+2+10,-1); // +10 to read new data by old
   fProperty       = -1;

   ResetInstanceCount();

   TClass *oldcl = (TClass*)gROOT->GetListOfClasses()->FindObject(name);

   if (oldcl && oldcl->TestBit(kLoading)) {
      // Do not recreate a class while it is already being created!
      return;
   }

   if (oldcl) {
      gROOT->RemoveClass(oldcl);
      // move the StreamerInfo immediately so that there are
      // properly updated!

      if (oldcl->CanIgnoreTObjectStreamer()) {
         IgnoreTObjectStreamer();
      }
      TVirtualStreamerInfo *info;

      TIter next(oldcl->GetStreamerInfos());
      while ((info = (TVirtualStreamerInfo*)next())) {
         // We need to force a call to BuildOld
         info->Clear("build");
         info->SetClass(this);
         fStreamerInfo->AddAtAndExpand(info,info->GetClassVersion());
      }
      oldcl->GetStreamerInfos()->Clear();

   }

   SetBit(kLoading);
   // Advertise ourself as the loading class for this class name
   TClass::AddClass(this);

   Bool_t isStl = kFALSE;

   if (!fClassInfo) {
      Bool_t shouldLoad = kFALSE;
      isStl = TClassEdit::IsSTLCont(name);

      if (gInterpreter->CheckClassInfo(name)) shouldLoad = kTRUE;
      else if (fImplFileLine>=0) {
         // If the TClass is being generated from a ROOT dictionary,
         // eventhough we do not seem to have a CINT dictionary for
         // the class, we will will try to load it anyway UNLESS
         // the class is an STL container (or string).
         // This is because we do not expect the CINT dictionary
         // to be present for all STL classes (and we can handle
         // the lack of CINT dictionary in that cases).

         shouldLoad = ! isStl;
      }

      if (shouldLoad) {
         if (!gInterpreter)
            ::Fatal("TClass::TClass", "gInterpreter not initialized");

         gInterpreter->SetClassInfo(this);   // sets fClassInfo pointer
         if (!fClassInfo) {
            gInterpreter->InitializeDictionaries();
            gInterpreter->SetClassInfo(this);
            if (IsZombie()) {
               TClass::RemoveClass(this);
               return;
            }
         }
      }
   }
   if (!silent && !fClassInfo && !isStl && fName.First('@')==kNPOS)
      ::Warning("TClass::TClass", "no dictionary for class %s is available", name);

   fgClassCount++;
   SetUniqueID(fgClassCount);

   // Make the typedef-expanded -> original hash table entries.
   // There may be several entries for any given key.
   // We only make entries if the typedef-expanded name
   // is different from the original name.
   TString resolvedThis;
   if (strchr (name, '<')) {
      resolvedThis = TClassEdit::ResolveTypedef (name, kTRUE);
      if (resolvedThis != name) {
         if (!fgClassTypedefHash) {
            fgClassTypedefHash = new THashTable (100, 5);
            fgClassTypedefHash->SetOwner (kTRUE);
         }

         fgClassTypedefHash->Add (new TNameMapNode (resolvedThis, name));
         SetBit (kHasNameMapNode);
      }

      TString resolvedShort =
       TClassEdit::ResolveTypedef
         (TClassEdit::ShortType(name,
                                TClassEdit::kDropStlDefault).c_str(),
          kTRUE);
      if (resolvedShort != name) {
         if (!fgClassShortTypedefHash) {
            fgClassShortTypedefHash = new THashTable (100, 5);
            fgClassShortTypedefHash->SetOwner (kTRUE);
         }

         fgClassShortTypedefHash->Add (new TNameMapNode (resolvedShort, name));
         SetBit (kHasNameMapNode);
      }
   }

   //In case a class with the same name had been created by TVirtualStreamerInfo
   //we must delete the old class, importing only the StreamerInfo structure
   //from the old dummy class.
   if (oldcl) {

      oldcl->ReplaceWith(this);
      delete oldcl;

   } else if (resolvedThis.Length() > 0 && fgClassTypedefHash) {

      // Check for existing equivalent.

      if (resolvedThis != name) {
         oldcl = (TClass*)gROOT->GetListOfClasses()->FindObject(resolvedThis);
         if (oldcl && oldcl != this)
            ForceReload (oldcl);
      }
      TIter next( fgClassTypedefHash->GetListForObject (resolvedThis) );
      while ( TNameMapNode* htmp = static_cast<TNameMapNode*> (next()) ) {
         if (resolvedThis != htmp->String()) continue;
         oldcl = (TClass*)gROOT->GetListOfClasses()->FindObject(htmp->fOrigName); // gROOT->GetClass (htmp->fOrigName, kFALSE);
         if (oldcl && oldcl != this) {
            ForceReload (oldcl);
         }
      }
   }
   if (fClassInfo) SetTitle(gCint->ClassInfo_Title(fClassInfo));

   ResetBit(kLoading);

   Int_t stl = TClassEdit::IsSTLCont(GetName(), 0);

   if ( stl || !strncmp(GetName(),"stdext::hash_",13) || !strncmp(GetName(),"__gnu_cxx::hash_",16) ) {
      fCollectionProxy = TVirtualStreamerInfo::Factory()->GenEmulatedProxy( GetName() );
      if (fCollectionProxy) {
         fSizeof = fCollectionProxy->Sizeof();
      } else if (!silent) {
         Warning("Init","Collection proxy for %s was not properly initialized!",GetName());
      }
      if (fStreamer==0) {
         fStreamer =  TVirtualStreamerInfo::Factory()->GenEmulatedClassStreamer( GetName() );
      }
   }

}

//______________________________________________________________________________
TClass::TClass(const TClass& cl) :
  TDictionary(cl),
  fStreamerInfo(cl.fStreamerInfo),
  fConversionStreamerInfo(cl.fConversionStreamerInfo),
  fRealData(cl.fRealData),
  fBase(cl.fBase),
  fData(cl.fData),
  fMethod(cl.fMethod),
  fAllPubData(cl.fAllPubData),
  fAllPubMethod(cl.fAllPubMethod),
  fClassMenuList(0),
  fDeclFileName(cl.fDeclFileName),
  fImplFileName(cl.fImplFileName),
  fDeclFileLine(cl.fDeclFileLine),
  fImplFileLine(cl.fImplFileLine),
  fInstanceCount(cl.fInstanceCount),
  fOnHeap(cl.fOnHeap),
  fCheckSum(cl.fCheckSum),
  fCollectionProxy(cl.fCollectionProxy),
  fClassVersion(cl.fClassVersion),
  fClassInfo(cl.fClassInfo),
  fContextMenuTitle(cl.fContextMenuTitle),
  fTypeInfo(cl.fTypeInfo),
  fShowMembers(cl.fShowMembers),
  fInterShowMembers(cl.fInterShowMembers),
  fStreamer(cl.fStreamer),
  fSharedLibs(cl.fSharedLibs),
  fIsA(cl.fIsA),
  fGlobalIsA(cl.fGlobalIsA),
  fIsAMethod(cl.fIsAMethod),
  fNew(cl.fNew),
  fNewArray(cl.fNewArray),
  fDelete(cl.fDelete),
  fDeleteArray(cl.fDeleteArray),
  fDestructor(cl.fDestructor),
  fDirAutoAdd(cl.fDirAutoAdd),
  fSizeof(cl.fSizeof),
  fVersionUsed(cl.fVersionUsed),
  fProperty(cl.fProperty),
  fInterStreamer(cl.fInterStreamer),
  fOffsetStreamer(cl.fOffsetStreamer),
  fStreamerType(cl.fStreamerType),
  fCurrentInfo(cl.fCurrentInfo),
  fRefStart(cl.fRefStart),
  fRefProxy(cl.fRefProxy),
  fSchemaRules(cl.fSchemaRules)
{
   //copy constructor
   
   R__ASSERT(0 /* TClass Object are not copyable */ );
}

//______________________________________________________________________________
TClass& TClass::operator=(const TClass& cl)
{
   //assignement operator
   if(this!=&cl) {
      R__ASSERT(0 /* TClass Object are not copyable */ );
   }
   return *this;
}

//______________________________________________________________________________
TClass::~TClass()
{
   // TClass dtor. Deletes all list that might have been created.

   // Remove from the typedef hashtables.
   if (fgClassTypedefHash && TestBit (kHasNameMapNode)) {
      TString resolvedThis = TClassEdit::ResolveTypedef (GetName(), kTRUE);
      TIter next (fgClassTypedefHash->GetListForObject (resolvedThis));
      while ( TNameMapNode* htmp = static_cast<TNameMapNode*> (next()) ) {
         if (resolvedThis == htmp->String() && htmp->fOrigName == GetName()) {
            fgClassTypedefHash->Remove (htmp);
            delete htmp;
            break;
         }
      }
   }
   if (fgClassShortTypedefHash && TestBit (kHasNameMapNode)) {
      TString resolvedShort =
       TClassEdit::ResolveTypedef
         (TClassEdit::ShortType(GetName(),
                                TClassEdit::kDropStlDefault).c_str(),
          kTRUE);
      TIter next (fgClassShortTypedefHash->GetListForObject (resolvedShort));
      while ( TNameMapNode* htmp = static_cast<TNameMapNode*> (next()) ) {
         if (resolvedShort == htmp->String() && htmp->fOrigName == GetName()) {
            fgClassShortTypedefHash->Remove (htmp);
            delete htmp;
            break;
         }
      }
   }
   

   // Not owning lists, don't call Delete()
   // But this still need to be done first because the TList desctructor
   // does access the object contained (via GetObject()->TestBit(kCanDelete))
   delete fStreamer;       fStreamer    =0;
   delete fAllPubData;     fAllPubData  =0;
   delete fAllPubMethod;   fAllPubMethod=0;

   if (fRefStart) {
      // Inform the TClassRef object that we are going away.
      fRefStart->ListReset();
      fRefStart = 0;
   }
   if (fBase)
      fBase->Delete();
   delete fBase;   fBase=0;

   if (fData)
      fData->Delete();
   delete fData;   fData = 0;

   if (fMethod)
      fMethod->Delete();
   delete fMethod;   fMethod=0;

   if (fRealData)
      fRealData->Delete();
   delete fRealData;  fRealData=0;

   if (fStreamerInfo)
      fStreamerInfo->Delete();
   delete fStreamerInfo; fStreamerInfo=0;

   if (fDeclFileLine >= -1)
      TClass::RemoveClass(this);

   gCint->ClassInfo_Delete(fClassInfo);  
   fClassInfo=0;

   if (fClassMenuList)
      fClassMenuList->Delete();
   delete fClassMenuList; fClassMenuList=0;

   if ( fInterStreamer ) gCint->CallFunc_Delete((CallFunc_t*)fInterStreamer);
   fInterStreamer=0;

   if (fInterShowMembers) gCint->CallFunc_Delete(fInterShowMembers);

   if ( fIsA ) delete fIsA;

   if ( fRefProxy ) fRefProxy->Release();
   fRefProxy = 0;

   delete fStreamer;
   delete fCollectionProxy;
   delete fIsAMethod;
   delete fSchemaRules;
   delete fConversionStreamerInfo;
}

//------------------------------------------------------------------------------
void TClass::AdoptSchemaRules( ROOT::TSchemaRuleSet *rules )
{
   // Adopt a new set of Data Model Evolution rules.

   delete fSchemaRules;
   fSchemaRules = rules;
   fSchemaRules->SetClass( this );
}

//------------------------------------------------------------------------------
const ROOT::TSchemaRuleSet* TClass::GetSchemaRules() const
{
   // Return the set of the schema rules if any.
   return fSchemaRules;
}

//------------------------------------------------------------------------------
ROOT::TSchemaRuleSet* TClass::GetSchemaRules(Bool_t create)
{
   // Return the set of the schema rules if any.
   // If create is true, create an empty set
   if (create && fSchemaRules == 0) {
      fSchemaRules = new ROOT::TSchemaRuleSet();
      fSchemaRules->SetClass( this );
   }
   return fSchemaRules;
}

//______________________________________________________________________________
void TClass::AddImplFile(const char* filename, int line) {

   // Currently reset the implementation file and line.
   // In the close future, it will actually add this file and line
   // to a "list" of implementation files.

   fImplFileName = filename;
   fImplFileLine = line;
}

//______________________________________________________________________________
void TClass::AddRef(TClassRef *ref)
{
   // Register a TClassRef object which points to this TClass object.
   // When this TClass object is deleted, 'ref' will be 'Reset'.

   if (fRefStart==0) {
      fRefStart = ref;
   } else {
      fRefStart->fPrevious = ref;
      ref->fNext = fRefStart;
      fRefStart = ref;
   }
}

//______________________________________________________________________________
Int_t TClass::AutoBrowse(TObject *obj, TBrowser *b)
{
   // Browse external object inherited from TObject.
   // It passes through inheritance tree and calls TBrowser::Add
   // in appropriate cases. Static function.

   if (!obj) return 0;

   char cbuf[1000]; *cbuf=0;

   TAutoInspector insp(b);
   obj->ShowMembers(insp,cbuf);
   return insp.fCount;
}

//______________________________________________________________________________
Int_t TClass::Browse(void *obj, TBrowser *b) const
{
   // Browse objects of of the class described by this TClass object.

   if (!obj) return 0;

   TClass *actual = GetActualClass(obj);
   if (IsTObject()) {
      // Call TObject::Browse.

      if (!fInterStreamer) {
         CalculateStreamerOffset();
      }
      TObject* realTObject = (TObject*)((size_t)obj + fOffsetStreamer);
      realTObject->Browse(b);
      return 1;
   } else if (actual != this) {
      return actual->Browse(obj, b);
   } else if (GetCollectionProxy()) {

      // do something useful.

   } else {
      char cbuf[1000]; *cbuf=0;

      TAutoInspector insp(b);
      CallShowMembers(obj,insp,cbuf,0);
      return insp.fCount;
   }

   return 0;
}

//______________________________________________________________________________
void TClass::Browse(TBrowser *b)
{
   // This method is called by a browser to get the class information.

   if (!fClassInfo) return;

   if (b) {
      if (!fRealData) BuildRealData();

      b->Add(GetListOfDataMembers(), "Data Members");
      b->Add(GetListOfRealData(), "Real Data Members");
      b->Add(GetListOfMethods(), "Methods");
      b->Add(GetListOfBases(), "Base Classes");
   }
}

//______________________________________________________________________________
void TClass::BuildRealData(void* pointer, Bool_t isTransient)
{
   // Build a full list of persistent data members.
   // Scans the list of all data members in the class itself and also
   // in all base classes. For each persistent data member, inserts a
   // TRealData object in the list fRealData.
   //
   // If pointer is not 0, uses the object at pointer
   // otherwise creates a temporary object of this class.

   // Only do this once.
   if (fRealData) {
      return;
   }

   // Handle emulated classes and STL containers specially.
   if (!fClassInfo || TClassEdit::IsSTLCont(GetName(), 0) || TClassEdit::IsSTLBitset(GetName())) {
      // We are an emulated class or an STL container.
      fRealData = new TList;
      BuildEmulatedRealData("", 0, this);
      return;
   }
 
   void* realDataObject = pointer;

   // If we are not given an object, and the class
   // is abstract (so that we cannot make one), give up.
   if ((!pointer) && (Property() & kIsAbstract)) {
      return;
   }

   // If we are not given an object, make one.
   // Note: We handle singletons carefully.
   if (!realDataObject) {
      if (!strcmp(GetName(), "TROOT")) {
         realDataObject = gROOT;
      } else if (!strcmp(GetName(), "TGWin32")) {
         realDataObject = gVirtualX;
      } else if (!strcmp(GetName(), "TGQt")) {
         realDataObject = gVirtualX;
      } else {
         realDataObject = New();
      }
   }

   // The following statement will recursively call
   // all the subclasses of this class.
   if (realDataObject) {
      char parent[256];
      parent[0] = 0;
      fRealData = new TList;

      TBuildRealData brd(realDataObject, this);

      // CallShowMember will force a call to InheritsFrom, which indirectly
      // calls TClass::GetClass.  It forces the loading of new typedefs in 
      // case some of them were not yet loaded.
      Bool_t wasTransient = brd.TestBit(TRealData::kTransient);
      if (isTransient) {
         brd.SetBit(TRealData::kTransient);
      }
      if ( ! CallShowMembers(realDataObject, brd, parent) ) {
         if ( brd.TestBit(TRealData::kTransient) ) {
            // This is a transient data member, so it is probably fine to not have 
            // access to its content.  However let's no mark it as definitively setup,
            // since another class might use this class for a persistent data member and
            // in this case we really want the error message.
            delete fRealData;
            fRealData = 0;            
         } else {
            Error("BuildRealData", "Cannot find any ShowMembers function for %s!", GetName());
         }
      }
      if (isTransient && !wasTransient) {
         brd.ResetBit(TRealData::kTransient);
      }

      // Take this opportunity to build the real data for base classes.
      // In case one base class is abstract, it would not be possible later
      // to create the list of real data for this abstract class.
      TBaseClass* base = 0;
      TIter next(GetListOfBases());
      while ((base = (TBaseClass*) next())) {
         if (base->IsSTLContainer()) {
            continue;
         }
         TClass* c = base->GetClassPointer();
         if (c) {
            c->BuildRealData(((char*) realDataObject) + base->GetDelta(), isTransient);
         }
      }
   }

   // Clean up any allocated temporary object.
   if (!pointer && realDataObject && (realDataObject != gROOT) && (realDataObject != gVirtualX)) {
      Int_t delta = GetBaseClassOffset(TObject::Class());
      if (delta >= 0) {
         TObject* tobj = (TObject*) (((char*) realDataObject) + delta);
         tobj->SetBit(kZombie); //this info useful in object destructor
         delete tobj;
         tobj = 0;
      } else {
         Destructor(realDataObject);
         realDataObject = 0;
      }
   }
}

//______________________________________________________________________________
void TClass::BuildEmulatedRealData(const char *name, Long_t offset, TClass *cl)
{
   // Build the list of real data for an emulated class

   TIter next(GetStreamerInfo()->GetElements());
   TStreamerElement *element;
   while ((element = (TStreamerElement*)next())) {
      Int_t etype    = element->GetType();
      Long_t eoffset = element->GetOffset();
      TClass *cle    = element->GetClassPointer();
      if (element->IsBase() || etype == TVirtualStreamerInfo::kBase) {
         //base class
         if (cle) cle->BuildEmulatedRealData(name,offset+eoffset,cl);
      } else if (etype == TVirtualStreamerInfo::kTObject ||
                 etype == TVirtualStreamerInfo::kTNamed ||
                 etype == TVirtualStreamerInfo::kObject || 
                 etype == TVirtualStreamerInfo::kAny) {
         //member class
         TRealData *rd = new TRealData(Form("%s%s",name,element->GetFullName()),offset+eoffset,0);
         if (gDebug > 0) printf(" Class: %s, adding TRealData=%s, offset=%ld\n",cl->GetName(),rd->GetName(),rd->GetThisOffset());
         cl->GetListOfRealData()->Add(rd);
         TString rdname(Form("%s%s.",name,element->GetFullName()));
         if (cle) cle->BuildEmulatedRealData(rdname,offset+eoffset,cl);
      } else {
         //others
         TString rdname(Form("%s%s",name,element->GetFullName()));
         TRealData *rd = new TRealData(rdname,offset+eoffset,0);
         if (gDebug > 0) printf(" Class: %s, adding TRealData=%s, offset=%ld\n",cl->GetName(),rd->GetName(),rd->GetThisOffset());
         cl->GetListOfRealData()->Add(rd);
      }
      //if (fClassInfo==0 && element->IsBase()) {
      //   if (fBase==0) fBase = new TList;
      //   TClass *base = element->GetClassPointer();
      //   fBase->Add(new TBaseClass(this, cl, eoffset));
      //}
   }
}


//______________________________________________________________________________
void TClass::CalculateStreamerOffset() const
{
   // Calculate the offset between an object of this class to
   // its base class TObject. The pointer can be adjusted by
   // that offset to access any virtual method of TObject like
   // Streamer() and ShowMembers().
   if (!fInterStreamer && fClassInfo) {
      CallFunc_t *f  = gCint->CallFunc_Factory();
      gCint->CallFunc_SetFuncProto(f,fClassInfo,"Streamer","TBuffer&",&fOffsetStreamer);
      fInterStreamer = f;
      fOffsetStreamer = const_cast<TClass*>(this)->GetBaseClassOffset(TObject::Class());
   }
}


//______________________________________________________________________________
Bool_t TClass::CallShowMembers(void* obj, TMemberInspector &insp, char *parent,
                               Int_t isATObject) const
{
   // Call ShowMembers() on the obj of this class type, passing insp and parent.
   // isATObject is -1 if unknown, 0 if it is not a TObject, and 1 if it is a TObject.
   // The function returns whether it was able to call ShowMembers().

   if (fShowMembers) {
      // This should always works since 'pointer' should be pointing
      // to an object of the actual type of this TClass object.
      fShowMembers(obj, insp, parent);
      return kTRUE;
   } else {

      if (isATObject == -1 && IsLoaded()) {
         // Force a call to InheritsFrom. This function indirectly
         // calls TClass::GetClass.  It forces the loading of new
         // typedefs in case some of them were not yet loaded.
         isATObject = (Int_t) (InheritsFrom(TObject::Class()));
      }

      if (isATObject == 1) {
         // We have access to the TObject interface, so let's use it.
         if (!fInterStreamer) {
            CalculateStreamerOffset();
         }
         TObject* realTObject = (TObject*)((size_t)obj + fOffsetStreamer);
         realTObject->ShowMembers(insp, parent);
         return kTRUE;
      } else if (fClassInfo) {
         
         // Always call ShowMembers via the interpreter. A direct call
         // like:
         //
         //      realDataObject->ShowMembers(brd, parent);
         //
         // will not work if the class derives from TObject but does not
         // have TObject as the leftmost base class.
         //

         if (!fInterShowMembers) {
            CallFunc_t* ism = gCint->CallFunc_Factory();
            Long_t offset = 0;
            
            R__LOCKGUARD2(gCINTMutex);
            gCint->CallFunc_SetFuncProto(ism,fClassInfo,"ShowMembers", "TMemberInspector&,char*", &offset);
            if (fInterStreamer && offset != fOffsetStreamer) {
               Error("CallShowMembers", "Logic Error: offset for Streamer() and ShowMembers() differ!");
               fInterShowMembers = 0;
               return kFALSE;
            }

            fInterShowMembers = ism;
         }
         if (!gCint->CallFunc_IsValid(fInterShowMembers)) {
            if (strcmp(GetName(), "string") == 0) {
               // For std::string we know that we do not have a ShowMembers
               // function and that it's okay.
               return kTRUE;
            }
            // Let the caller protest:
            // Error("CallShowMembers", "Cannot find any ShowMembers function for %s!", GetName());
            return kFALSE;
         } else {
            R__LOCKGUARD2(gCINTMutex);
            gCint->CallFunc_ResetArg(fInterShowMembers);
            gCint->CallFunc_SetArg(fInterShowMembers,(long) &insp);
            gCint->CallFunc_SetArg(fInterShowMembers,(long) parent);
            void* address = (void*) (((long) obj) + fOffsetStreamer);
            gCint->CallFunc_Exec((CallFunc_t*)fInterShowMembers,address);
            return kTRUE;
         }
      } else if (TVirtualStreamerInfo* sinfo = GetStreamerInfo()) {
         
         sinfo->CallShowMembers(obj,insp,parent);
         return kTRUE;
      } // isATObject
   } // fShowMembers is set

   return kFALSE;
}

//______________________________________________________________________________
Bool_t TClass::CanSplit() const
{
   // Return true if the data member of this TClass can be saved separately.

   // Note: add the possibility to set it for the class and the derived class.
   // save the info in TVirtualStreamerInfo
   // deal with the info in MakeProject
   if (fRefProxy)                 return kFALSE;
   if (InheritsFrom("TRef"))      return kFALSE;
   if (InheritsFrom("TRefArray")) return kFALSE;
   if (InheritsFrom("TArray"))    return kFALSE;
   if (fName.BeginsWith("TVectorT<")) return kFALSE;
   if (fName.BeginsWith("TMatrixT<")) return kFALSE;
   if (InheritsFrom("TCollection") && !InheritsFrom("TClonesArray")) return kFALSE;

   // If we do not have a showMembers and we have a streamer,
   // we are in the case of class that can never be split since it is
   // opaque to us.
   if (GetShowMembersWrapper()==0 && GetStreamer()!=0) {

      // the exception are the STL containers.
      if (GetCollectionProxy()==0) {
         // We do NOT have a collection.  The class is true opaque
         return kFALSE;

      } else {

         // However we do not split collections of collections
         // nor collections of strings
         // nor collections of pointers
         // (actually we __could__ split collection of pointers to non-virtual class,
         //  but we dont for now).

         if (GetCollectionProxy()->HasPointers()) return kFALSE;

         TClass *valueClass = GetCollectionProxy()->GetValueClass();
         if (valueClass == 0) return kFALSE;
         if (valueClass==TString::Class() || valueClass==TClass::GetClass("string"))
            return kFALSE;
         if (!valueClass->CanSplit()) return kFALSE;
         if (valueClass->GetCollectionProxy() != 0) return kFALSE;

         Int_t stl = -TClassEdit::IsSTLCont(GetName(), 0);
         if ((stl==TClassEdit::kMap || stl==TClassEdit::kMultiMap)
              && valueClass->GetClassInfo()==0)
         {
            return kFALSE;
         }
      }
   }
   
   if (Size()==1) {
      // 'Empty' class there is nothing to split!.
      return kFALSE;
   }

   TClass *ncThis = const_cast<TClass*>(this);
   TIter nextb(ncThis->GetListOfBases());
   TBaseClass *base;
   while((base = (TBaseClass*)nextb())) {
      if (!TClass::GetClass(base->GetName())) return kFALSE;
   }

   return kTRUE;
}

//______________________________________________________________________________
TObject *TClass::Clone(const char *new_name) const
{
   // Create a Clone of this TClass object using a different name but using the same 'dictionary'.
   // This effectively creates a hard alias for the class name.

   if (new_name == 0 || new_name[0]=='\0' || fName == new_name) {
      Error("Clone","The name of the class must be changed when cloning a TClass object.");
      return 0;
   }
   // Temporarily remove the original from the list of classes.
   TClass::RemoveClass(const_cast<TClass*>(this));
 
   TClass *copy;
   if (fTypeInfo) {
      copy = new TClass(GetName(),
                        fClassVersion,
                        *fTypeInfo,
                        new TIsAProxy(*fTypeInfo),
                        fShowMembers,
                        GetDeclFileName(),
                        GetImplFileName(),
                        GetDeclFileLine(),
                        GetImplFileLine());
   } else {
      copy = new TClass(GetName(),
                        fClassVersion,
                        GetDeclFileName(),
                        GetImplFileName(),
                        GetDeclFileLine(),
                        GetImplFileLine());
      copy->fShowMembers = fShowMembers;
   }
   // Remove the copy before renaming it
   TClass::RemoveClass(copy);
   copy->SetName(new_name);
   TClass::AddClass(copy);

   copy->SetNew(fNew);
   copy->SetNewArray(fNewArray);
   copy->SetDelete(fDelete);
   copy->SetDeleteArray(fDeleteArray);
   copy->SetDestructor(fDestructor);
   copy->SetDirectoryAutoAdd(fDirAutoAdd);
   if (fStreamer) {
      copy->AdoptStreamer(fStreamer->Generate());
   }
   // If IsZombie is true, something went wrong and we will not be
   // able to properly copy the collection proxy
   if (fCollectionProxy && !copy->IsZombie()) {
      copy->CopyCollectionProxy(*fCollectionProxy);
   }
   copy->SetClassSize(fSizeof);
   if (fRefProxy) {
      copy->AdoptReferenceProxy( fRefProxy->Clone() );
   }
   TClass::AddClass(const_cast<TClass*>(this));
   return copy;
}   

//______________________________________________________________________________
void TClass::CopyCollectionProxy(const TVirtualCollectionProxy &orig)
{
   // Copy the argument.

//     // This code was used too quickly test the STL Emulation layer
//    Int_t k = TClassEdit::IsSTLCont(GetName());
//    if (k==1||k==-1) return;

   delete fCollectionProxy;
   fCollectionProxy = orig.Generate();
}


//______________________________________________________________________________
void TClass::Draw(Option_t *option)
{
   // Draw detailed class inheritance structure.
   // If a class B inherits from a class A, the description of B is drawn
   // on the right side of the description of A.
   // Member functions overridden by B are shown in class A with a blue line
   // erasing the corresponding member function

   if (!fClassInfo) return;

   TVirtualPad *padsav = gPad;

   // Should we create a new canvas?
   TString opt=option;
   if (!padsav || !opt.Contains("same")) {
      TVirtualPad *padclass = (TVirtualPad*)(gROOT->GetListOfCanvases())->FindObject("R__class");
      if (!padclass) {
         gROOT->ProcessLine("new TCanvas(\"R__class\",\"class\",20,20,1000,750);");
      } else {
         padclass->cd();
      }
   }

   if (gPad) gPad->DrawClassObject(this,option);

   if (padsav) padsav->cd();
}

//______________________________________________________________________________
void TClass::Dump(void *obj) const
{
   // Dump contents of object on stdout.
   // Using the information in the object dictionary
   // each data member is interpreted.
   // If a data member is a pointer, the pointer value is printed
   // 'obj' is assume to point to an object of the class describe by this TClass
   //
   // The following output is the Dump of a TArrow object:
   //   fAngle                   0           Arrow opening angle (degrees)
   //   fArrowSize               0.2         Arrow Size
   //   fOption.*fData
   //   fX1                      0.1         X of 1st point
   //   fY1                      0.15        Y of 1st point
   //   fX2                      0.67        X of 2nd point
   //   fY2                      0.83        Y of 2nd point
   //   fUniqueID                0           object unique identifier
   //   fBits                    50331648    bit field status word
   //   fLineColor               1           line color
   //   fLineStyle               1           line style
   //   fLineWidth               1           line width
   //   fFillColor               19          fill area color
   //   fFillStyle               1001        fill area style

   Printf("==>Dumping object at:%lx, class=%s\n",(Long_t)obj,GetName());
   char parent[256];
   parent[0] = 0;
   TDumpMembers dm;
   if (!CallShowMembers(obj, dm, parent)) {
      Info("Dump", "No ShowMembers function, dumping disabled");
   }
}

//______________________________________________________________________________
char *TClass::EscapeChars(const char *text) const
{
   // Introduce an escape character (@) in front of a special chars.
   // You need to use the result immediately before it is being overwritten.

   static char name[128];
   Int_t nch = strlen(text);
   if (nch > 127) nch = 127;
   Int_t icur = -1;
   for (Int_t i = 0; i < nch; i++) {
      icur++;
      if (text[i] == '\"' || text[i] == '[' || text[i] == '~' ||
          text[i] == ']'  || text[i] == '&' || text[i] == '#' ||
          text[i] == '!'  || text[i] == '^' || text[i] == '<' ||
          text[i] == '?'  || text[i] == '>') {
         name[icur] = '@';
         icur++;
      }
      name[icur] = text[i];
   }
   name[icur+1] = 0;
   return name;
}

//______________________________________________________________________________
TClass *TClass::GetActualClass(const void *object) const
{
   // Return a pointer the the real class of the object.
   // This is equivalent to object->IsA() when the class has a ClassDef.
   // It is REQUIRED that object is coming from a proper pointer to the
   // class represented by 'this'.
   // Example: Special case:
   //    class MyClass : public AnotherClass, public TObject
   // then on return, one must do:
   //    TObject *obj = (TObject*)((void*)myobject)directory->Get("some object of MyClass");
   //    MyClass::Class()->GetActualClass(obj); // this would be wrong!!!
   // Also if the class represented by 'this' and NONE of its parents classes
   // have a virtual ptr table, the result will be 'this' and NOT the actual
   // class.

   if (object==0 || !IsLoaded() ) return (TClass*)this;

   if (fIsA) {
      return (*fIsA)(object); // ROOT::IsA((ThisClass*)object);
   } else if (fGlobalIsA) {
      return fGlobalIsA(this,object);
   } else {
      //Always call IsA via the interpreter. A direct call like
      //      object->IsA(brd, parent);
      //will not work if the class derives from TObject but not as primary
      //inheritance.
      if (fIsAMethod==0) {
         fIsAMethod = new TMethodCall((TClass*)this, "IsA", "");

         if (!fIsAMethod->GetMethod()) {
            delete fIsAMethod;
            fIsAMethod = 0;
            Error("IsA","Can not find any IsA function for %s!",GetName());
            return (TClass*)this;
         }

      }
      char * char_result = 0;
      fIsAMethod->Execute((void*)object, &char_result);
      return (TClass*)char_result;
   }
}

//______________________________________________________________________________
TClass *TClass::GetBaseClass(const char *classname)
{
   // Return pointer to the base class "classname". Returns 0 in case
   // "classname" is not a base class. Takes care of multiple inheritance.

   // check if class name itself is equal to classname
   if (strcmp(GetName(), classname) == 0) return this;

   if (!fClassInfo) return 0;

   TObjLink *lnk = GetListOfBases() ? fBase->FirstLink() : 0;

   // otherwise look at inheritance tree
   while (lnk) {
      TClass     *c, *c1;
      TBaseClass *base = (TBaseClass*) lnk->GetObject();
      c = base->GetClassPointer();
      if (c) {
         if (strcmp(c->GetName(), classname) == 0) return c;
         c1 = c->GetBaseClass(classname);
         if (c1) return c1;
      }
      lnk = lnk->Next();
   }
   return 0;
}

//______________________________________________________________________________
TClass *TClass::GetBaseClass(const TClass *cl)
{
   // Return pointer to the base class "cl". Returns 0 in case "cl"
   // is not a base class. Takes care of multiple inheritance.

   // check if class name itself is equal to classname
   if (cl == this) return this;

   if (!fClassInfo) return 0;

   TObjLink *lnk = GetListOfBases() ? fBase->FirstLink() : 0;

   // otherwise look at inheritance tree
   while (lnk) {
      TClass     *c, *c1;
      TBaseClass *base = (TBaseClass*) lnk->GetObject();
      c = base->GetClassPointer();
      if (c) {
         if (cl == c) return c;
         c1 = c->GetBaseClass(cl);
         if (c1) return c1;
      }
      lnk = lnk->Next();
   }
   return 0;
}

//______________________________________________________________________________
Int_t TClass::GetBaseClassOffsetRecurse(const TClass *cl)
{
   // Return data member offset to the base class "cl".
   // Returns -1 in case "cl" is not a base class.
   // Returns -2 if cl is a base class, but we can't find the offset
   // because it's virtual.
   // Takes care of multiple inheritance.

   // check if class name itself is equal to classname
   if (cl == this) return 0;

   if (!fClassInfo) {
      TVirtualStreamerInfo *sinfo = GetCurrentStreamerInfo();
      if (!sinfo) return -1;
      TStreamerElement *element;
      Int_t offset = 0;

      TObjArray &elems = *(sinfo->GetElements());
      Int_t size = elems.GetLast()+1;
      for(Int_t i=0; i<size; i++) {
         element = (TStreamerElement*)elems[i];
         if (element->IsA() == TStreamerBase::Class()) {
            TStreamerBase *base = (TStreamerBase*)element;
            TClass *baseclass = base->GetClassPointer();
            if (!baseclass) return -1;
            Int_t subOffset = baseclass->GetBaseClassOffsetRecurse(cl);
            if (subOffset == -2) return -2;
            if (subOffset != -1) return offset+subOffset;
            offset += baseclass->Size();
         }
      }
      return -1;
   }

   TClass     *c;
   Int_t      off;
   TBaseClass *inh;
   TObjLink *lnk = 0;
   if (fBase==0) lnk = GetListOfBases()->FirstLink();
   else lnk = fBase->FirstLink();

   // otherwise look at inheritance tree
   while (lnk) {
      inh = (TBaseClass *)lnk->GetObject();
      //use option load=kFALSE to avoid a warning like:
      //"Warning in <TClass::TClass>: no dictionary for class TRefCnt is available"
      //We can not afford to not have the class if it exist, so we
      //use kTRUE.
      c = inh->GetClassPointer(kTRUE); // kFALSE);
      if (c) {
         if (cl == c) {
            if ((inh->Property() & G__BIT_ISVIRTUALBASE) != 0)
               return -2;
            return inh->GetDelta();
         }
         off = c->GetBaseClassOffsetRecurse(cl);
         if (off == -2) return -2;
         if (off != -1) return off + inh->GetDelta();
      }
      lnk = lnk->Next();
   }
   return -1;
}

//______________________________________________________________________________
Int_t TClass::GetBaseClassOffset(const TClass *cl)
{
   // Return data member offset to the base class "cl".
   // Returns -1 in case "cl" is not a base class.
   // Takes care of multiple inheritance.

   Int_t offset = GetBaseClassOffsetRecurse (cl);
   if (offset == -2) {
      // Can we get the offset from CINT?
      if (cl->GetClassInfo()) {
         Long_t base_tagnum = gCint->ClassInfo_Tagnum(cl->GetClassInfo());
         BaseClassInfo_t *t = gCint->BaseClassInfo_Factory(GetClassInfo());
         while (gCint->BaseClassInfo_Next(t,0)) {
            if (gCint->BaseClassInfo_Tagnum(t) == base_tagnum) {
               if ((gCint->BaseClassInfo_Property(t) & G__BIT_ISVIRTUALBASE) != 0) {
                  break;
               }
               int off = gCint->BaseClassInfo_Offset(t);
               gCint->BaseClassInfo_Delete(t);
               return off;
            }
         }
         gCint->BaseClassInfo_Delete(t);
      }
      offset = -1;
   }
   return offset;
}

//______________________________________________________________________________
TClass *TClass::GetBaseDataMember(const char *datamember)
{
   // Return pointer to (base) class that contains datamember.

   if (!fClassInfo) return 0;

   // Check if data member exists in class itself
   TDataMember *dm = GetDataMember(datamember);
   if (dm) return this;

   // if datamember not found in class, search in next base classes
   TBaseClass *inh;
   TIter       next(GetListOfBases());
   while ((inh = (TBaseClass *) next())) {
      TClass *c = inh->GetClassPointer();
      if (c) {
         TClass *cdm = c->GetBaseDataMember(datamember);
         if (cdm) return cdm;
      }
   }

   return 0;
}

namespace {
   // A local Helper class used to keep 2 pointer (the collection proxy
   // and the class streamer) in the thread local storage.

   struct TClassLocalStorage {
      TClassLocalStorage() : fCollectionProxy(0), fStreamer(0) {};

      TVirtualCollectionProxy *fCollectionProxy;
      TClassStreamer          *fStreamer;

      static TClassLocalStorage *GetStorage(const TClass *cl) {
         void **thread_ptr = (*gThreadTsd)(0,1);
         if (thread_ptr) {
            if (*thread_ptr==0) *thread_ptr = new TExMap();
            TExMap *lmap = (TExMap*)(*thread_ptr);
            ULong_t hash = TString::Hash(&cl, sizeof(void*));
            ULong_t local = 0;
            UInt_t slot;
            if ((local = (ULong_t)lmap->GetValue(hash, (Long_t)cl, slot)) != 0) {
            } else {
               local = (ULong_t) new TClassLocalStorage();
               lmap->AddAt(slot, hash, (Long_t)cl, local);
            }
            return (TClassLocalStorage*)local;
         }
         return 0;
      }
   };
}

//______________________________________________________________________________
TVirtualCollectionProxy *TClass::GetCollectionProxy() const
{
   // Return the proxy describinb the collection (if any).

   if (gThreadTsd && fCollectionProxy) {
      TClassLocalStorage *local = TClassLocalStorage::GetStorage(this);
      if (local == 0) return fCollectionProxy;
      if (local->fCollectionProxy==0) local->fCollectionProxy = fCollectionProxy->Generate();
      return local->fCollectionProxy;
   }
   return fCollectionProxy;
}

//______________________________________________________________________________
TClassStreamer *TClass::GetStreamer() const
{
   // Return the proxy describinb the collection (if any).

   if (gThreadTsd && fStreamer) {
      TClassLocalStorage *local = TClassLocalStorage::GetStorage(this);
      if (local==0) return fStreamer;
      if (local->fStreamer==0) {
         local->fStreamer = fStreamer->Generate();
         const type_info &orig = ( typeid(*fStreamer) );
         const type_info &copy = ( typeid(*local->fStreamer) );
         if (strcmp(orig.name(),copy.name())!=0) {
            Warning("GetStreamer","For %s, the TClassStreamer passed does not properly implement the Generate method (%s vs %s\n",GetName(),orig.name(),copy.name());
         }
      }
      return local->fStreamer;
   }
   return fStreamer;
}

//______________________________________________________________________________
TVirtualIsAProxy* TClass::GetIsAProxy() const
{
   // Return the proxy implementing the IsA functionality.

   return fIsA;
}


//______________________________________________________________________________
TClass *TClass::GetClass(const char *name, Bool_t load, Bool_t silent)
{
   // Static method returning pointer to TClass of the specified class name.
   // If load is true an attempt is made to obtain the class by loading
   // the appropriate shared library (directed by the rootmap file).
   // If silent is 'true', do not warn about missing dictionary for the class.
   // (typically used for class that are used only for transient members)
   // Returns 0 in case class is not found.

   if (!name || !strlen(name)) return 0;
   if (!gROOT->GetListOfClasses())    return 0;

   TClass *cl = (TClass*)gROOT->GetListOfClasses()->FindObject(name);

   if (!cl) {
      TString resolvedName = TClassEdit::ResolveTypedef(name,kTRUE).c_str();
      cl = (TClass*)gROOT->GetListOfClasses()->FindObject(resolvedName);
   }

   if (cl) {

      if (cl->IsLoaded()) return cl;

      //we may pass here in case of a dummy class created by TVirtualStreamerInfo
      load = kTRUE;

      if (TClassEdit::IsSTLCont(name)) {

         const char *altname = gCint->GetInterpreterTypeName(name);
         if (altname && strcmp(altname,name)!=0) {

            // Remove the existing (soon to be invalid) TClass object to
            // avoid an infinite recursion.
            gROOT->GetListOfClasses()->Remove(cl);
            TClass *newcl = GetClass(altname,load);

            // since the name are different but we got a TClass, we assume
            // we need to replace and delete this class.
            assert(newcl!=cl);
            cl->ReplaceWith(newcl);
            delete cl;
            return newcl;
         }
      }

   } else {

      if (!TClassEdit::IsSTLCont(name)) {

         // If the name is actually an STL container we prefer the
         // short name rather than the true name (at least) in
         // a first try!

         TDataType *objType = gROOT->GetType(name, load);
         if (objType) {
            const char *typdfName = objType->GetTypeName();
            if (typdfName && strcmp(typdfName, name)) {
               cl = TClass::GetClass(typdfName, load);
               return cl;
            }
         }

      } else {

         cl = gROOT->FindSTLClass(name,kFALSE,silent);

         if (cl) {
            if (cl->IsLoaded()) return cl;

            //we may pass here in case of a dummy class created by TVirtualStreamerInfo
            //return TClass::GetClass(cl->GetName(),kTRUE);
            return TClass::GetClass(cl->GetName(),kTRUE);
         }

      }

   }

   if (!load) return 0;

   TClass *loadedcl = 0;
   if (cl) loadedcl = gROOT->LoadClass(cl->GetName(),silent);
   else    loadedcl = gROOT->LoadClass(name,silent);

   if (loadedcl) return loadedcl;

   if (cl) return cl;  // If we found the class but we already have a dummy class use it.

   static const char *full_string_name = "basic_string<char,char_traits<char>,allocator<char> >";
   if (strcmp(name,full_string_name)==0
      || ( strncmp(name,"std::",5)==0 && ((strcmp(name+5,"string")==0)||(strcmp(name+5,full_string_name)==0)))) {
      return TClass::GetClass("string");
   }
   if (TClassEdit::IsSTLCont(name)) {

      return gROOT->FindSTLClass(name,kTRUE,silent);

   } else if ( strncmp(name,"std::",5)==0 ) {

      return TClass::GetClass(name+5,load);

   } else if ( strstr(name,"std::") != 0 ) {

      // Let's try without the std:: in the template parameters.
      TString rname( TClassEdit::ResolveTypedef(name,kTRUE) );
      if (rname != name) {
         return TClass::GetClass( rname, load );
      }
   }

   if (!strcmp(name, "long long")||!strcmp(name,"unsigned long long"))
      return 0; // reject long longs

   //last attempt. Look in CINT list of all (compiled+interpreted) classes

   // CheckClassInfo might modify the content of its parameter if it is
   // a template and has extra or missing space (eg. one<two<tree>> becomes
   // one<two<three> >
   char *modifiable_name = new char[strlen(name)*2];
   strcpy(modifiable_name,name);
   if (gInterpreter->CheckClassInfo(modifiable_name)) {
      const char *altname = gInterpreter->GetInterpreterTypeName(modifiable_name,kTRUE);
      if (strcmp(altname,name)!=0) {
         // altname now contains the full name of the class including a possible
         // namespace if there has been a using namespace statement.
         delete [] modifiable_name;
         return GetClass(altname,load);
      }
      TClass *ncl = new TClass(name, 1, 0, 0, -1, -1, silent);
      if (!ncl->IsZombie()) {
         delete [] modifiable_name;
         return ncl;
      }
      delete ncl;
   }
   delete [] modifiable_name;
   return 0;
}

//______________________________________________________________________________
THashTable *TClass::GetClassShortTypedefHash() {
   // Return the class namesmassaged with TClassEdit::ShortType with kDropStlDefault.
   return fgClassShortTypedefHash;
}

//______________________________________________________________________________
TClass *TClass::GetClass(const type_info& typeinfo, Bool_t load, Bool_t /* silent */)
{
   // Return pointer to class with name.

   if (!gROOT->GetListOfClasses())    return 0;

//printf("TClass::GetClass called, typeinfo.name=%s\n",typeinfo.name());
   TClass* cl = fgIdMap->Find(typeinfo.name());

   if (cl) {
      if (cl->IsLoaded()) return cl;
      //we may pass here in case of a dummy class created by TVirtualStreamerInfo
      load = kTRUE;
   } else {
     // Note we might need support for typedefs and simple types!

     //      TDataType *objType = GetType(name, load);
     //if (objType) {
     //    const char *typdfName = objType->GetTypeName();
     //    if (typdfName && strcmp(typdfName, name)) {
     //       cl = GetClass(typdfName, load);
     //       return cl;
     //    }
     // }
   }

   if (!load) return 0;

   VoidFuncPtr_t dict = TClassTable::GetDict(typeinfo);
   if (dict) {
      (dict)();
      cl = GetClass(typeinfo,kFALSE);
      if (cl) cl->PostLoadCheck();
      return cl;
   }
   if (cl) return cl;

   TIter next(gROOT->GetListOfClassGenerators());
   TClassGenerator *gen;
   while( (gen = (TClassGenerator*) next()) ) {
      cl = gen->GetClass(typeinfo,load);
      if (cl) {
         cl->PostLoadCheck();
         return cl;
      }
   }

   //last attempt. Look in CINT list of all (compiled+interpreted) classes
   //   if (gInterpreter->CheckClassInfo(name)) {
   //      TClass *ncl = new TClass(name, 1, 0, 0, 0, -1, -1);
   //      if (!ncl->IsZombie()) return ncl;
   //      delete ncl;
   //   }
   return 0;
}

//______________________________________________________________________________
VoidFuncPtr_t  TClass::GetDict (const char *cname)
{
   // Return a pointer to the dictionary loading function generated by
   // rootcint

   return TClassTable::GetDict(cname);
}

//______________________________________________________________________________
VoidFuncPtr_t  TClass::GetDict (const type_info& info)
{
   // Return a pointer to the dictionary loading function generated by
   // rootcint

   return TClassTable::GetDict(info);
}

//______________________________________________________________________________
TDataMember *TClass::GetDataMember(const char *datamember) const
{
   // Return pointer to datamember object with name "datamember".

   if (!fClassInfo) return 0;

   // Strip off leading *'s and trailing [
   const Int_t size_buffer = 256;
   char memb[size_buffer];
   char *s = (char*)datamember;
   while (*s == '*') s++;

   size_t len = strlen(s);
   if (len > size_buffer - 2)
      len = size_buffer - 2;
   strncpy(memb, s, len);
   memb[len] = 0;

   if ((s = strchr(memb, '['))) {
      *s = 0;
      len = strlen(memb);
   }

   TDataMember *dm;
   TIter   next(((TClass*)this)->GetListOfDataMembers());

   while ((dm = (TDataMember *) next()))
      if (len >= size_buffer - 2) {
         if (strncmp(memb, dm->GetName(), len) == 0)
            return dm;
      } else
         if (strcmp(memb, dm->GetName()) == 0)
            return dm;
   return 0;
}

//______________________________________________________________________________
Long_t TClass::GetDataMemberOffset(const char *name) const
{
   // return offset for member name. name can be a data member in
   // the class itself, one of its base classes, or one member in
   // one of the aggregated classes.
   //
   // In case of an emulated class, the list of emulated TRealData is built

   TRealData *rd = GetRealData(name);
   if (rd) return rd->GetThisOffset();
   if (strchr(name,'[')==0) {
      // If this is a simple name there is a chance to find it in the
      // StreamerInfo even if we did not find it in the RealData.
      // For example an array name would be fArray[3] in RealData but
      // just fArray in the streamerInfo.
      TVirtualStreamerInfo *info = const_cast<TClass*>(this)->GetCurrentStreamerInfo();
      if (info) {
         return info->GetOffset(name);
      }
   }
   return 0;
}

//______________________________________________________________________________
TRealData* TClass::GetRealData(const char* name) const
{
   // -- Return pointer to TRealData element with name "name".
   //
   // Name can be a data member in the class itself,
   // one of its base classes, or a member in
   // one of the aggregated classes.
   //
   // In case of an emulated class, the list of emulated TRealData is built.
   //

   if (!fRealData) {
      const_cast<TClass*>(this)->BuildRealData();
   }

   if (!fRealData) {
      return 0;
   }

   if (!name) {
      return 0;
   }

   // First try just the whole name.
   TRealData* rd = (TRealData*) fRealData->FindObject(name);
   if (rd) {
      return rd;
   }

   std::string givenName(name);

   // Try ignoring the array dimensions.
   std::string::size_type firstBracket = givenName.find_first_of("[");
   if (firstBracket != std::string::npos) {
      // -- We are looking for an array data member.
      std::string nameNoDim(givenName.substr(0, firstBracket));
      TObjLink* lnk = fRealData->FirstLink();
      while (lnk) {
         TObject* obj = lnk->GetObject();
         std::string objName(obj->GetName());
         std::string::size_type pos = objName.find_first_of("[");
         // Only match arrays to arrays for now.
         if (pos != std::string::npos) {
            objName.erase(pos);
            if (objName == nameNoDim) {
               return static_cast<TRealData*>(obj);
            }
         }
         lnk = lnk->Next();
      }
   }

   // Now try it as a pointer.
   std::ostringstream ptrname;
   ptrname << "*" << givenName;
   rd = (TRealData*) fRealData->FindObject(ptrname.str().c_str());
   if (rd) {
      return rd;
   }

   // Check for a dot in the name.
   std::string::size_type firstDot = givenName.find_first_of(".");
   if (firstDot == std::string::npos) {
      // -- Not found, a simple name, all done.
      return 0;
   }

   //
   //  At this point the name has a dot in it, so it is the name
   //  of some contained sub-object.
   //

   // May be a pointer like in TH1: fXaxis.fLabels (in TRealdata is named fXaxis.*fLabels)
   std::string::size_type lastDot = givenName.find_last_of(".");
   std::ostringstream starname;
   starname << givenName.substr(0, lastDot) << ".*" << givenName.substr(lastDot + 1);
   rd = (TRealData*) fRealData->FindObject(starname.str().c_str());
   if (rd) {
      return rd;
   }

   // Strip the first component, it may be the name of
   // the branch (old TBranchElement code), and try again.
   std::string firstDotName(givenName.substr(firstDot + 1));

   // New attempt starting after the first "." if any,
   // this allows for the case that the first component
   // may have been a branch name (for TBranchElement).
   rd = (TRealData*) fRealData->FindObject(firstDotName.c_str());
   if (rd) {
      return rd;
   }

   // New attempt starting after the first "." if any,
   // but this time try ignoring the array dimensions.
   // Again, we are allowing for the case that the first
   // component may have been a branch name (for TBranchElement).
   std::string::size_type firstDotBracket = firstDotName.find_first_of("[");
   if (firstDotBracket != std::string::npos) {
      // -- We are looking for an array data member.
      std::string nameNoDim(firstDotName.substr(0, firstDotBracket));
      TObjLink* lnk = fRealData->FirstLink();
      while (lnk) {
         TObject* obj = lnk->GetObject();
         std::string objName(obj->GetName());
         std::string::size_type pos = objName.find_first_of("[");
         // Only match arrays to arrays for now.
         if (pos != std::string::npos) {
            objName.erase(pos);
            if (objName == nameNoDim) {
               return static_cast<TRealData*>(obj);
            }
         }
         lnk = lnk->Next();
      }
   }

   // New attempt starting after the first "." if any,
   // but this time check for a pointer type.  Again, we
   // are allowing for the case that the first component
   // may have been a branch name (for TBranchElement).
   ptrname.str("");
   ptrname << "*" << firstDotName;
   rd = (TRealData*) fRealData->FindObject(ptrname.str().c_str());
   if (rd) {
      return rd;
   }

   // Last attempt in case a member has been changed from
   // a static array to a pointer, for example the member
   // was arr[20] and is now *arr.
   //
   // Note: In principle, one could also take into account
   // the opposite situation where a member like *arr has
   // been converted to arr[20].
   //
   // FIXME: What about checking after the first dot as well?
   //
   std::string::size_type bracket = starname.str().find_first_of("[");
   if (bracket == std::string::npos) {
      return 0;
   }
   rd = (TRealData*) fRealData->FindObject(starname.str().substr(0, bracket).c_str());
   if (rd) {
      return rd;
   }

   // Not found;
   return 0;
}

//______________________________________________________________________________
const char *TClass::GetSharedLibs()
{
   // Get the list of shared libraries containing the code for class cls.
   // The first library in the list is the one containing the class, the
   // others are the libraries the first one depends on. Returns 0
   // in case the library is not found.

   if (!gInterpreter) return 0;

   if (fSharedLibs.IsNull())
      fSharedLibs = gInterpreter->GetClassSharedLibs(fName);

   return !fSharedLibs.IsNull() ? fSharedLibs.Data() : 0;
}

//______________________________________________________________________________
TList *TClass::GetListOfBases()
{
   // Return list containing the TBaseClass(es) of a class.

   if (!fBase) {
      if (!fClassInfo) return 0;

      if (!gInterpreter)
         Fatal("GetListOfBases", "gInterpreter not initialized");

      gInterpreter->CreateListOfBaseClasses(this);
   }
   return fBase;
}

//______________________________________________________________________________
TList *TClass::GetListOfDataMembers()
{
   // Return list containing the TDataMembers of a class.

   if (!fClassInfo) {
      if (!fData) fData = new TList;
      return fData;
   }

   if (!fData) {
      if (!gInterpreter)
         Fatal("GetListOfDataMembers", "gInterpreter not initialized");

      gInterpreter->CreateListOfDataMembers(this);
   }
   return fData;
}

//______________________________________________________________________________
TList *TClass::GetListOfMethods()
{
   // Return list containing the TMethods of a class.

   if (!fClassInfo) {
      if (!fMethod) fMethod = new THashList;
      return fMethod;
   }

   if (!fMethod) {
      if (!gInterpreter)
         Fatal("GetListOfMethods", "gInterpreter not initialized");

      gInterpreter->CreateListOfMethods(this);
   } else {
      gInterpreter->UpdateListOfMethods(this);
   }
   return fMethod;
}

//______________________________________________________________________________
TList *TClass::GetListOfAllPublicMethods()
{
   // Returns a list of all public methods of this class and its base classes.
   // Refers to a subset of the methods in GetListOfMethods() so don't do
   // GetListOfAllPublicMethods()->Delete().
   // Algorithm used to get the list is:
   // - put all methods of the class in the list (also protected and private
   //   ones).
   // - loop over all base classes and add only those methods not already in the
   //   list (also protected and private ones).
   // - once finished, loop over resulting list and remove all private and
   //   protected methods.

   if (!fAllPubMethod) {
      fAllPubMethod = new TList;

      // put all methods in the list
      fAllPubMethod->AddAll(GetListOfMethods());

      // loop over all base classes and add new methods
      TIter nextBaseClass(GetListOfBases());
      TBaseClass *pB;
      TMethod    *p;
      while ((pB = (TBaseClass*) nextBaseClass())) {
         if (!pB->GetClassPointer()) continue;
         TIter next(pB->GetClassPointer()->GetListOfAllPublicMethods());
         TList temp;
         while ((p = (TMethod*) next()))
            if (!fAllPubMethod->Contains(p->GetName()))
               temp.Add(p);
         fAllPubMethod->AddAll(&temp);
         temp.Clear();
      }

      // loop over list and remove all non-public methods
      TIter next(fAllPubMethod);
      while ((p = (TMethod*) next()))
         if (!(p->Property() & kIsPublic)) fAllPubMethod->Remove(p);
   }
   return fAllPubMethod;
}

//______________________________________________________________________________
TList *TClass::GetListOfAllPublicDataMembers()
{
   // Returns a list of all public data members of this class and its base
   // classes. Refers to a subset of the data members in GetListOfDatamembers()
   // so don't do GetListOfAllPublicDataMembers()->Delete().

   if (!fAllPubData) {
      fAllPubData = new TList;
      TIter next(GetListOfDataMembers());
      TDataMember *p;

      while ((p = (TDataMember*) next()))
         if (p->Property() & kIsPublic) fAllPubData->Add(p);

      TIter next_BaseClass(GetListOfBases());
      TBaseClass *pB;
      while ((pB = (TBaseClass*) next_BaseClass())) {
         if (!pB->GetClassPointer()) continue;
         fAllPubData->AddAll(pB->GetClassPointer()->GetListOfAllPublicDataMembers() );
      }
   }
   return fAllPubData;
}

//______________________________________________________________________________
void TClass::GetMenuItems(TList *list)
{
   // Returns list of methods accessible by context menu.

   if (!fClassInfo) return;

   // get the base class
   TIter nextBase(GetListOfBases(), kIterBackward);
   TBaseClass *baseClass;
   while ((baseClass = (TBaseClass *) nextBase())) {
      TClass *base = baseClass->GetClassPointer();
      if (base) base->GetMenuItems(list);
   }

   // remove methods redefined in this class with no menu
   TMethod *method, *m;
   TIter next(GetListOfMethods(), kIterBackward);
   while ((method = (TMethod*)next())) {
      m = (TMethod*)list->FindObject(method->GetName());
      if (method->IsMenuItem()) {
         if (!m)
            list->AddFirst(method);
      } else {
         if (m && m->GetNargs() == method->GetNargs())
            list->Remove(m);
      }
   }
}

//______________________________________________________________________________
Bool_t TClass::IsFolder(void *obj) const
{
   // Return kTRUE if the class has elements.

   return Browse(obj,(TBrowser*)0);
}

//______________________________________________________________________________
void TClass::RemoveRef(TClassRef *ref)
{
   // Unregister the TClassRef object.

   if (ref==fRefStart) {
      fRefStart = ref->fNext;
      if (fRefStart) fRefStart->fPrevious = 0;
      ref->fPrevious = ref->fNext = 0;
   } else {
      TClassRef *next = ref->fNext;
      ref->fPrevious->fNext = next;
      if (next) next->fPrevious = ref->fPrevious;
      ref->fPrevious = ref->fNext = 0;
   }
}

//______________________________________________________________________________
void TClass::ReplaceWith(TClass *newcl, Bool_t recurse) const
{
   // Inform the other objects to replace this object by the new TClass (newcl)

   //we must update the class pointers pointing to 'this' in all TStreamerElements
   TIter nextClass(gROOT->GetListOfClasses());
   TClass *acl;
   TVirtualStreamerInfo *info;
   TList tobedeleted;

   TString corename( TClassEdit::ResolveTypedef(newcl->GetName()) );

   if ( strchr( corename.Data(), '<' ) == 0 ) {
      // not a template, let's skip
      recurse = kFALSE;
   }

   while ((acl = (TClass*)nextClass())) {
      if (recurse && acl!=newcl && acl!=this) {

         TString aclCorename( TClassEdit::ResolveTypedef(acl->GetName()) );

         if (aclCorename == corename) {

            // 'acl' represents the same class as 'newcl' (and this object)

            acl->ReplaceWith(newcl, kFALSE);
            tobedeleted.Add(acl);
         }
      }

      TIter nextInfo(acl->GetStreamerInfos());
      while ((info = (TVirtualStreamerInfo*)nextInfo())) {

         info->Update(this, newcl);
      }

      if (acl->GetCollectionProxy() && acl->GetCollectionProxy()->GetValueClass()==this) {
         acl->GetCollectionProxy()->SetValueClass(newcl);
         // We should also inform all the TBranchElement :( but we do not have a master list :(
      }
   }

   TIter delIter( &tobedeleted );
   while ((acl = (TClass*)delIter())) {
      delete acl;
   }

}

//______________________________________________________________________________
void TClass::ResetClassInfo(Long_t tagnum)
{
   // Make sure that the current ClassInfo is up to date.

   if (fClassInfo && gCint->ClassInfo_Tagnum(fClassInfo) != tagnum) {
      gCint->ClassInfo_Init(fClassInfo,(Int_t)tagnum);
      if (fBase) {
         fBase->Delete();
         delete fBase; fBase = 0;
      }
   }
}

//______________________________________________________________________________
void TClass::ResetMenuList()
{
   // Resets the menu list to it's standard value.

   if (fClassMenuList)
      fClassMenuList->Delete();
   else
      fClassMenuList = new TList();
   fClassMenuList->Add(new TClassMenuItem(TClassMenuItem::kPopupStandardList, this));
}

//______________________________________________________________________________
void TClass::ls(Option_t *options) const
{
   // The ls function lists the contents of a class on stdout. Ls output
   // is typically much less verbose then Dump().
   // If options contains 'streamerinfo', run ls on the list of streamerInfos
   // and the list of conversion streamerInfos.
   
   TNamed::ls(options);
   if (options==0 || options[0]==0) return;
   
   if (strstr(options,"streamerinfo")!=0) {
      GetStreamerInfos()->ls(options);

      if (fConversionStreamerInfo) {
         std::map<std::string, TObjArray*>::iterator it;
         std::map<std::string, TObjArray*>::iterator end = fConversionStreamerInfo->end();
         for( it = fConversionStreamerInfo->begin(); it != end; ++it ) {
            it->second->ls(options);
         }
      }
   }
}
   
//______________________________________________________________________________
void TClass::MakeCustomMenuList()
{
   // Makes a customizable version of the popup menu list, i.e. makes a list
   // of TClassMenuItem objects of methods accessible by context menu.
   // The standard (and different) way consists in having just one element
   // in this list, corresponding to the whole standard list.
   // Once the customizable version is done, one can remove or add elements.

   TClassMenuItem *menuItem;

   // Make sure fClassMenuList is initialized and empty.
   GetMenuList()->Delete();

   TList* methodList = new TList;
   GetMenuItems(methodList);

   TMethod *method;
   TMethodArg *methodArg;
   TClass  *classPtr = 0;
   TIter next(methodList);

   while ((method = (TMethod*) next())) {
      // if go to a mother class method, add separator
      if (classPtr != method->GetClass()) {
         menuItem = new TClassMenuItem(TClassMenuItem::kPopupSeparator, this);
         fClassMenuList->AddLast(menuItem);
         classPtr = method->GetClass();
      }
      // Build the signature of the method
      TString sig;
      TList* margsList = method->GetListOfMethodArgs();
      TIter nextarg(margsList);
      while ((methodArg = (TMethodArg*)nextarg())) {
         sig = sig+","+methodArg->GetFullTypeName();
      }
      if (sig.Length()!=0) sig.Remove(0,1);  // remove first comma
      menuItem = new TClassMenuItem(TClassMenuItem::kPopupUserFunction, this,
                                    method->GetName(), method->GetName(),0,
                                    sig.Data(),-1,TClassMenuItem::kIsSelf);
      if (method->IsMenuItem() == kMenuToggle) menuItem->SetToggle();
      fClassMenuList->Add(menuItem);
   }
   delete methodList;
}

//______________________________________________________________________________
void TClass::Move(void *arenaFrom, void *arenaTo) const
{
   // Register the fact that an object was moved from the memory location
   // 'arenaFrom' to the memory location 'arenaTo'.

   // If/when we have access to a copy constructor (or better to a move
   // constructor), this function should also perform the data move.
   // For now we just information the repository.

   if (!fClassInfo && !fCollectionProxy) {
      MoveAddressInRepository("TClass::Move",arenaFrom,arenaTo,this);
   }
}

//______________________________________________________________________________
TList *TClass::GetMenuList() const {
   // Return the list of menu items associated with the class.
   if (!fClassMenuList) {
      fClassMenuList = new TList();
      fClassMenuList->Add(new TClassMenuItem(TClassMenuItem::kPopupStandardList, const_cast<TClass*>(this)));
   }
   return fClassMenuList;
}


//______________________________________________________________________________
TMethod *TClass::GetMethodAny(const char *method)
{
   // Return pointer to method without looking at parameters.
   // Does not look in (possible) base classes.

   if (!fClassInfo) return 0;
   return (TMethod*) GetListOfMethods()->FindObject(method);
}

//______________________________________________________________________________
TMethod *TClass::GetMethodAllAny(const char *method)
{
   // Return pointer to method without looking at parameters.
   // Does look in all base classes.

   if (!fClassInfo) return 0;

   TMethod* m = GetMethodAny(method);
   if (m) return m;

   TBaseClass *base;
   TIter       nextb(GetListOfBases());
   while ((base = (TBaseClass *) nextb())) {
      TClass *c = base->GetClassPointer();
      if (c) {
         m = c->GetMethodAllAny(method);
         if (m) return m;
      }
   }

   return 0;
}

//______________________________________________________________________________
TMethod *TClass::GetMethod(const char *method, const char *params)
{
   // Find the best method (if there is one) matching the parameters.
   // The params string must contain argument values, like "3189, \"aap\", 1.3".
   // The function invokes GetClassMethod to search for a possible method
   // in the class itself or in its base classes. Returns 0 in case method
   // is not found.

   if (!fClassInfo) return 0;

   if (!gInterpreter)
      Fatal("GetMethod", "gInterpreter not initialized");

   Long_t faddr = (Long_t)gInterpreter->GetInterfaceMethod(this, method,
                                                           params);
   if (!faddr) return 0;

   // loop over all methods in this class (and its baseclasses) till
   // we find a TMethod with the same faddr


   TMethod *m;

#if defined(R__WIN32)
   // On windows CINT G__exec_bytecode can (seemingly) have several values :(
   // So we can not easily determine whether something is interpreted or
   // so the optimization of not looking at the mangled name can not be
   // used
   m = GetClassMethod(method,params);

#else
   if (faddr == (Long_t)gCint->GetExecByteCode()) {
      // the method is actually interpreted, its address is
      // not a discriminant (it always point to the same
      // function pointed by CINT G__exec_bytecode.
      m = GetClassMethod(method,params);
   } else {
      m = GetClassMethod(faddr);
   }
#endif

   if (m) return m;

   TBaseClass *base;
   TIter       next(GetListOfBases());
   while ((base = (TBaseClass *) next())) {
      TClass *c = base->GetClassPointer();
      if (c) {
         m = c->GetMethod(method,params);
         if (m) return m;
      }
   }
   Error("GetMethod",
         "\nDid not find matching TMethod <%s> with \"%s\" for %s",
         method,params,GetName());
   return 0;
}

//______________________________________________________________________________
TMethod *TClass::GetMethodWithPrototype(const char *method, const char *proto)
{
   // Find the method with a given prototype. The proto string must be of the
   // form: "char*,int,double". Returns 0 in case method is not found.

   if (!fClassInfo) return 0;

   if (!gInterpreter)
      Fatal("GetMethod", "gInterpreter not initialized");

   Long_t faddr = (Long_t)gInterpreter->GetInterfaceMethodWithPrototype(this,
                                                              method, proto);
   if (!faddr) return 0;

   // loop over all methods in this class (and its baseclasses) till
   // we find a TMethod with the same faddr

   TMethod *m = GetClassMethod(faddr);
   if (m) return m;

   TBaseClass *base;
   TIter       next(GetListOfBases());
   while ((base = (TBaseClass *) next())) {
      TClass *c = base->GetClassPointer();
      if (c) {
         m = c->GetMethodWithPrototype(method,proto);
         if (m) return m;
      }
   }
   Error("GetMethod", "Did not find matching TMethod (should never happen)");
   return 0;
}

//______________________________________________________________________________
TMethod *TClass::GetClassMethod(Long_t faddr)
{
   // Look for a method in this class that has the interface function
   // address faddr.

   if (!fClassInfo) return 0;

   TMethod *m;
   TIter    next(GetListOfMethods());
   while ((m = (TMethod *) next())) {
      if (faddr == (Long_t)m->InterfaceMethod())
         return m;
   }
   return 0;
}

//______________________________________________________________________________
TMethod *TClass::GetClassMethod(const char *name, const char* params)
{
   // Look for a method in this class that has the name and
   // signature

   if (!fClassInfo) return 0;

   // Need to go through those loops to get the signature from
   // the valued params (i.e. from "1.0,3" to "double,int")

   TList* bucketForMethod = ((THashList*)GetListOfMethods())->GetListForObject(name);
   if (bucketForMethod) {
      R__LOCKGUARD2(gCINTMutex);
      CallFunc_t  *func = gCint->CallFunc_Factory();
      Long_t       offset;
      gCint->CallFunc_SetFunc(func,GetClassInfo(), name, params, &offset);
      MethodInfo_t *info = gCint->CallFunc_FactoryMethod(func);
      TMethod request(info,this);
      TMethod *m;
      TIter    next(bucketForMethod);
      while ((m = (TMethod *) next())) {
         if (!strcmp(name,m->GetName())
             &&!strcmp(request.GetSignature(),m->GetSignature())) {
            gCint->CallFunc_Delete(func);
            return m;
         }
      }
      gCint->CallFunc_Delete(func);
   }
   return 0;
}

//______________________________________________________________________________
Int_t TClass::GetNdata()
{
   // Return the number of data members of this class
   // Note that in case the list of data members is not yet created, it will be done
   // by GetListOfDataMembers().

   if (!fClassInfo) return 0;

   TList *lm = GetListOfDataMembers();
   if (lm)
      return lm->GetSize();
   else
      return 0;
}

//______________________________________________________________________________
Int_t TClass::GetNmethods()
{
   // Return the number of methods of this class
   // Note that in case the list of methods is not yet created, it will be done
   // by GetListOfMethods().

   if (!fClassInfo) return 0;

   TList *lm = GetListOfMethods();
   if (lm)
      return lm->GetSize();
   else
      return 0;
}

//______________________________________________________________________________
TVirtualStreamerInfo* TClass::GetStreamerInfo(Int_t version) const
{
   // returns a pointer to the TVirtualStreamerInfo object for version
   // If the object doest not exist, it is created
   //
   // Note: There are two special version numbers:
   //
   //       0: Use the class version from the currently loaded class library.
   //      -1: Assume no class library loaded (emulated class).
   //
   // Warning:  If we create a new streamer info, whether or not the build
   //           optimizes is controlled externally to us by a global variable!
   //           Don't call us unless you have set that variable properly
   //           with TStreamer::Optimize()!
   //

   // Handle special version, 0 means currently loaded version.
   // Warning:  This may be -1 for an emulated class.
   if (version == 0) {
      version = fClassVersion;
   }
   if (!fStreamerInfo) {
      fStreamerInfo = new TObjArray(version + 10, -1);
   } else {
      Int_t ninfos = fStreamerInfo->GetSize();
      if ((version < -1) || (version >= ninfos)) {
         Error("GetStreamerInfo", "class: %s, attempting to access a wrong version: %d", GetName(), version);
         // FIXME: Shouldn't we go to -1 here, or better just abort?
         version = 0;
      }
   }
   TVirtualStreamerInfo* sinfo = (TVirtualStreamerInfo*) fStreamerInfo->At(version);
   if (!sinfo && (version != fClassVersion)) {
      // When the requested version does not exist we return
      // the TVirtualStreamerInfo for the currently loaded class vesion.
      // FIXME: This arguably makes no sense, we should warn and return nothing instead.
      // Note: This is done for STL collactions
      // Note: fClassVersion could be -1 here (for an emulated class).
      sinfo = (TVirtualStreamerInfo*) fStreamerInfo->At(fClassVersion);
   }
   if (!sinfo) {
      // We just were not able to find a streamer info, we have to make a new one.
      sinfo = TVirtualStreamerInfo::Factory()->NewInfo(const_cast<TClass*>(this));
      fStreamerInfo->AddAtAndExpand(sinfo, fClassVersion);
      if (gDebug > 0) {
         printf("Creating StreamerInfo for class: %s, version: %d\n", GetName(), fClassVersion);
      }
      if (fClassInfo || fCollectionProxy) {
         // If we do not have a StreamerInfo for this version and we do not
         // have dictionary information nor a proxy, there is nothing to build!
         //
         // Warning:  Whether or not the build optimizes is controlled externally
         //           to us by a global variable!  Don't call us unless you have
         //           set that variable properly with TStreamer::Optimize()!
         //
         // FIXME: Why don't we call BuildOld() like we do below?  Answer: We are new and so don't have to do schema evolution?
         sinfo->Build();
      }
   } else {
      if (!sinfo->GetOffsets()) {
         // Streamer info has not been compiled, but exists.
         // Therefore it was read in from a file and we have to do schema evolution?
         // Or it didn't have a dictionary before, but does now?
         sinfo->BuildOld();
      }
      if (sinfo->IsOptimized() && !TVirtualStreamerInfo::CanOptimize()) {
         // Undo optimization if the global flag tells us to.
         sinfo->Compile();
      }
   }
   // Cache the current info if we now have it.
   if (version == fClassVersion) {
      fCurrentInfo = sinfo;
   }
   return sinfo;
}

//______________________________________________________________________________
void TClass::IgnoreTObjectStreamer(Bool_t ignore)
{
   //  When the class kIgnoreTObjectStreamer bit is set, the automatically
   //  generated Streamer will not call TObject::Streamer.
   //  This option saves the TObject space overhead on the file.
   //  However, the information (fBits, fUniqueID) of TObject is lost.
   //
   //  Note that this function must be called for the class deriving
   //  directly from TObject, eg, assuming that BigTrack derives from Track
   //  and Track derives from TObject, one must do:
   //     Track::Class()->IgnoreTObjectStreamer();
   //  and not:
   //     BigTrack::Class()->IgnoreTObjectStreamer();

   if ( ignore &&  TestBit(kIgnoreTObjectStreamer)) return;
   if (!ignore && !TestBit(kIgnoreTObjectStreamer)) return;
   TVirtualStreamerInfo *sinfo = GetCurrentStreamerInfo();
   if (sinfo) {
      if (sinfo->GetOffsets()) {
         // -- Warn the user that what he is doing cannot work.
         // Note: The reason is that TVirtualStreamerInfo::Build() examines
         // the kIgnoreTObjectStreamer bit and sets the TStreamerElement
         // type for the TObject base class streamer element it creates
         // to -1 as a flag.  Later on the TStreamerInfo::Compile()
         // member function sees the flag and does not insert the base
         // class element into the compiled streamer info.  None of this
         // machinery works correctly if we are called after the streamer
         // info has already been built and compiled.
         Error("IgnoreTObjectStreamer","Must be called before the creation of StreamerInfo");
         return;
      }
   }
   if (ignore) SetBit  (kIgnoreTObjectStreamer);
   else        ResetBit(kIgnoreTObjectStreamer);
}

//______________________________________________________________________________
Bool_t TClass::InheritsFrom(const char *classname) const
{
   // Return kTRUE if this class inherits from a class with name "classname".
   // note that the function returns KTRUE in case classname is the class itself

   if (strcmp(GetName(), classname) == 0) return kTRUE;

   if (!fClassInfo) return InheritsFrom(TClass::GetClass("classname"));

   // cast const away (only for member fBase which can be set in GetListOfBases())
   if (((TClass *)this)->GetBaseClass(classname)) return kTRUE;
   return kFALSE;
}

//______________________________________________________________________________
Bool_t TClass::InheritsFrom(const TClass *cl) const
{
   // Return kTRUE if this class inherits from class cl.
   // note that the function returns KTRUE in case cl is the class itself

   if (cl == this) return kTRUE;

   if (!fClassInfo) {
      TVirtualStreamerInfo *sinfo = ((TClass *)this)->GetCurrentStreamerInfo();
      if (sinfo==0) sinfo = GetStreamerInfo();
      TIter next(sinfo->GetElements());
      TStreamerElement *element;
      while ((element = (TStreamerElement*)next())) {
         if (element->IsA() == TStreamerBase::Class()) {
            TClass *clbase = element->GetClassPointer();
            if (!clbase) return kFALSE; //missing class
            if (clbase->InheritsFrom(cl)) return kTRUE;
         }
      }
      return kFALSE;
   }
   // cast const away (only for member fBase which can be set in GetListOfBases())
   if (((TClass *)this)->GetBaseClass(cl)) return kTRUE;
   return kFALSE;
}

//______________________________________________________________________________
void *TClass::DynamicCast(const TClass *cl, void *obj, Bool_t up)
{
   // Cast obj of this class type up to baseclass cl if up is true.
   // Cast obj of this class type down from baseclass cl if up is false.
   // If this class is not a baseclass of cl return 0, else the pointer
   // to the cl part of this (up) or to this (down).

   if (cl == this) return obj;

   if (!fClassInfo) return 0;

   Int_t off;
   if ((off = GetBaseClassOffset(cl)) != -1) {
      if (up)
         return (void*)((Long_t)obj+off);
      else
         return (void*)((Long_t)obj-off);
   }
   return 0;
}

//______________________________________________________________________________
void *TClass::New(ENewType defConstructor) const
{
   // Return a pointer to a newly allocated object of this class.
   // The class must have a default constructor. For meaning of
   // defConstructor, see TClass::IsCallingNew().
   //
   // The constructor actually called here can be customized by
   // using the rootcint pragma:
   //    #pragma link C++ ioctortype UserClass;
   // For example, with this pragma and a class named MyClass,
   // this method will called the first of the following 3
   // constructors which exists and is public:
   //    MyClass(UserClass*);
   //    MyClass(TRootIOCtor*);
   //    MyClass(); // Or a constructor with all its arguments defaulted.
   //
   // When more than one pragma ioctortype is used, the first seen as priority
   // For example with:
   //    #pragma link C++ ioctortype UserClass1;
   //    #pragma link C++ ioctortype UserClass2;
   // We look in the following order:
   //    MyClass(UserClass1*);
   //    MyClass(UserClass2*);
   //    MyClass(TRootIOCtor*);
   //    MyClass(); // Or a constructor with all its arguments defaulted.
   //

   void* p = 0;

   if (fNew) {
      // We have the new operator wrapper function,
      // so there is a dictionary and it was generated
      // by rootcint, so there should be a default
      // constructor we can call through the wrapper.
      fgCallingNew = defConstructor;
      p = fNew(0);
      fgCallingNew = kRealNew;
      if (!p) {
         //Error("New", "cannot create object of class %s version %d", GetName(), fClassVersion);
         Error("New", "cannot create object of class %s", GetName());
      }
   } else if (fClassInfo) {
      // We have the dictionary but do not have the
      // constructor wrapper, so the dictionary was
      // not generated by rootcint.  Let's try to
      // create the object by having the interpreter
      // call the new operator, hopefully the class
      // library is loaded and there will be a default
      // constructor we can call.
      // [This is very unlikely to work, but who knows!]
      fgCallingNew = defConstructor;
      R__LOCKGUARD2(gCINTMutex);
      p = gCint->ClassInfo_New(GetClassInfo());
      fgCallingNew = kRealNew;
      if (!p) {
         //Error("New", "cannot create object of class %s version %d", GetName(), fClassVersion);
         Error("New", "cannot create object of class %s", GetName());
      }
   } else if (!fClassInfo && fCollectionProxy) {
      // There is no dictionary at all, so this is an emulated
      // class; however we do have the services of a collection proxy,
      // so this is an emulated STL class.
      fgCallingNew = defConstructor;
      p = fCollectionProxy->New();
      fgCallingNew = kRealNew;
      if (!p) {
         //Error("New", "cannot create object of class %s version %d", GetName(), fClassVersion);
         Error("New", "cannot create object of class %s", GetName());
      }
   } else if (!fClassInfo && !fCollectionProxy) {
      // There is no dictionary at all and we do not have
      // the services of a collection proxy available, so
      // use the streamer info to approximate calling a
      // constructor (basically we just make sure that the
      // pointer data members are null, unless they are marked
      // as preallocated with the "->" comment, in which case
      // we default-construct an object to point at).

      // Do not register any TObject's that we create
      // as a result of creating this object.
      // FIXME: Why do we do this?
      // FIXME: Partial Answer: Is this because we may never actually deregister them???

      Bool_t statsave = GetObjectStat();
      SetObjectStat(kFALSE);

      TVirtualStreamerInfo* sinfo = GetStreamerInfo();
      if (!sinfo) {
         Error("New", "Cannot construct class '%s' version %d, no streamer info available!", GetName(), fClassVersion);
         return 0;
      }

      fgCallingNew = defConstructor;
      p = sinfo->New();
      fgCallingNew = kRealNew;

      // FIXME: Mistake?  See note above at the GetObjectStat() call.
      // Allow TObject's to be registered again.
      SetObjectStat(statsave);

      // Register the object for special handling in the destructor.
      if (p) {
         RegisterAddressInRepository("New",p,this);
      }
   } else {
      Error("New", "This cannot happen!");
   }

   return p;
}

//______________________________________________________________________________
void *TClass::New(void *arena, ENewType defConstructor) const
{
   // Return a pointer to a newly allocated object of this class.
   // The class must have a default constructor. For meaning of
   // defConstructor, see TClass::IsCallingNew().

   void* p = 0;

   if (fNew) {
      // We have the new operator wrapper function,
      // so there is a dictionary and it was generated
      // by rootcint, so there should be a default
      // constructor we can call through the wrapper.
      fgCallingNew = defConstructor;
      p = fNew(arena);
      fgCallingNew = kRealNew;
      if (!p) {
         Error("New with placement", "cannot create object of class %s version %d at address %p", GetName(), fClassVersion, arena);
      }
   } else if (fClassInfo) {
      // We have the dictionary but do not have the
      // constructor wrapper, so the dictionary was
      // not generated by rootcint.  Let's try to
      // create the object by having the interpreter
      // call the new operator, hopefully the class
      // library is loaded and there will be a default
      // constructor we can call.
      // [This is very unlikely to work, but who knows!]
      fgCallingNew = defConstructor;
      R__LOCKGUARD2(gCINTMutex);
      p = gCint->ClassInfo_New(GetClassInfo(),arena);
      fgCallingNew = kRealNew;
      if (!p) {
         Error("New with placement", "cannot create object of class %s version %d at address %p", GetName(), fClassVersion, arena);
      }
   } else if (!fClassInfo && fCollectionProxy) {
      // There is no dictionary at all, so this is an emulated
      // class; however we do have the services of a collection proxy,
      // so this is an emulated STL class.
      fgCallingNew = defConstructor;
      p = fCollectionProxy->New(arena);
      fgCallingNew = kRealNew;
   } else if (!fClassInfo && !fCollectionProxy) {
      // There is no dictionary at all and we do not have
      // the services of a collection proxy available, so
      // use the streamer info to approximate calling a
      // constructor (basically we just make sure that the
      // pointer data members are null, unless they are marked
      // as preallocated with the "->" comment, in which case
      // we default-construct an object to point at).

      // ???BUG???  ???WHY???
      // Do not register any TObject's that we create
      // as a result of creating this object.
      Bool_t statsave = GetObjectStat();
      SetObjectStat(kFALSE);

      TVirtualStreamerInfo* sinfo = GetStreamerInfo();
      if (!sinfo) {
         Error("New with placement", "Cannot construct class '%s' version %d at address %p, no streamer info available!", GetName(), fClassVersion, arena);
         return 0;
      }

      fgCallingNew = defConstructor;
      p = sinfo->New(arena);
      fgCallingNew = kRealNew;

      // ???BUG???
      // Allow TObject's to be registered again.
      SetObjectStat(statsave);

      // Register the object for special handling in the destructor.
      if (p) {
         RegisterAddressInRepository("TClass::New with placement",p,this);
      }
   } else {
      Error("New with placement", "This cannot happen!");
   }

   return p;
}

//______________________________________________________________________________
void *TClass::NewArray(Long_t nElements, ENewType defConstructor) const
{
   // Return a pointer to a newly allocated array of objects
   // of this class.
   // The class must have a default constructor. For meaning of
   // defConstructor, see TClass::IsCallingNew().

   void* p = 0;

   if (fNewArray) {
      // We have the new operator wrapper function,
      // so there is a dictionary and it was generated
      // by rootcint, so there should be a default
      // constructor we can call through the wrapper.
      fgCallingNew = defConstructor;
      p = fNewArray(nElements, 0);
      fgCallingNew = kRealNew;
      if (!p) {
         Error("NewArray", "cannot create object of class %s version %d", GetName(), fClassVersion);
      }
   } else if (fClassInfo) {
      // We have the dictionary but do not have the
      // constructor wrapper, so the dictionary was
      // not generated by rootcint.  Let's try to
      // create the object by having the interpreter
      // call the new operator, hopefully the class
      // library is loaded and there will be a default
      // constructor we can call.
      // [This is very unlikely to work, but who knows!]
      fgCallingNew = defConstructor;
      R__LOCKGUARD2(gCINTMutex);
      p = gCint->ClassInfo_New(GetClassInfo(),nElements);
      fgCallingNew = kRealNew;
      if (!p) {
         Error("NewArray", "cannot create object of class %s version %d", GetName(), fClassVersion);
      }
   } else if (!fClassInfo && fCollectionProxy) {
      // There is no dictionary at all, so this is an emulated
      // class; however we do have the services of a collection proxy,
      // so this is an emulated STL class.
      fgCallingNew = defConstructor;
      p = fCollectionProxy->NewArray(nElements);
      fgCallingNew = kRealNew;
   } else if (!fClassInfo && !fCollectionProxy) {
      // There is no dictionary at all and we do not have
      // the services of a collection proxy available, so
      // use the streamer info to approximate calling a
      // constructor (basically we just make sure that the
      // pointer data members are null, unless they are marked
      // as preallocated with the "->" comment, in which case
      // we default-construct an object to point at).

      // ???BUG???  ???WHY???
      // Do not register any TObject's that we create
      // as a result of creating this object.
      Bool_t statsave = GetObjectStat();
      SetObjectStat(kFALSE);

      TVirtualStreamerInfo* sinfo = GetStreamerInfo();
      if (!sinfo) {
         Error("NewArray", "Cannot construct class '%s' version %d, no streamer info available!", GetName(), fClassVersion);
         return 0;
      }

      fgCallingNew = defConstructor;
      p = sinfo->NewArray(nElements);
      fgCallingNew = kRealNew;

      // ???BUG???
      // Allow TObject's to be registered again.
      SetObjectStat(statsave);

      // Register the object for special handling in the destructor.
      if (p) {
         RegisterAddressInRepository("TClass::NewArray",p,this);
      }
   } else {
      Error("NewArray", "This cannot happen!");
   }

   return p;
}

//______________________________________________________________________________
void *TClass::NewArray(Long_t nElements, void *arena, ENewType defConstructor) const
{
   // Return a pointer to a newly allocated object of this class.
   // The class must have a default constructor. For meaning of
   // defConstructor, see TClass::IsCallingNew().

   void* p = 0;

   if (fNewArray) {
      // We have the new operator wrapper function,
      // so there is a dictionary and it was generated
      // by rootcint, so there should be a default
      // constructor we can call through the wrapper.
      fgCallingNew = defConstructor;
      p = fNewArray(nElements, arena);
      fgCallingNew = kRealNew;
      if (!p) {
         Error("NewArray with placement", "cannot create object of class %s version %d at address %p", GetName(), fClassVersion, arena);
      }
   } else if (fClassInfo) {
      // We have the dictionary but do not have the constructor wrapper,
      // so the dictionary was not generated by rootcint (it was made either
      // by cint or by some external mechanism).  Let's try to create the
      // object by having the interpreter call the new operator, either the
      // class library is loaded and there is a default constructor we can
      // call, or the class is interpreted and we will call the default
      // constructor that way, or no default constructor is available and
      // we fail.
      fgCallingNew = defConstructor;
      R__LOCKGUARD2(gCINTMutex);
      p = gCint->ClassInfo_New(GetClassInfo(),nElements, arena);
      fgCallingNew = kRealNew;
      if (!p) {
         Error("NewArray with placement", "cannot create object of class %s version %d at address %p", GetName(), fClassVersion, arena);
      }
   } else if (!fClassInfo && fCollectionProxy) {
      // There is no dictionary at all, so this is an emulated
      // class; however we do have the services of a collection proxy,
      // so this is an emulated STL class.
      fgCallingNew = defConstructor;
      p = fCollectionProxy->NewArray(nElements, arena);
      fgCallingNew = kRealNew;
   } else if (!fClassInfo && !fCollectionProxy) {
      // There is no dictionary at all and we do not have
      // the services of a collection proxy available, so
      // use the streamer info to approximate calling a
      // constructor (basically we just make sure that the
      // pointer data members are null, unless they are marked
      // as preallocated with the "->" comment, in which case
      // we default-construct an object to point at).

      // ???BUG???  ???WHY???
      // Do not register any TObject's that we create
      // as a result of creating this object.
      Bool_t statsave = GetObjectStat();
      SetObjectStat(kFALSE);

      TVirtualStreamerInfo* sinfo = GetStreamerInfo();
      if (!sinfo) {
         Error("NewArray with placement", "Cannot construct class '%s' version %d at address %p, no streamer info available!", GetName(), fClassVersion, arena);
         return 0;
      }

      fgCallingNew = defConstructor;
      p = sinfo->NewArray(nElements, arena);
      fgCallingNew = kRealNew;

      // ???BUG???
      // Allow TObject's to be registered again.
      SetObjectStat(statsave);

      if (fStreamerType & kEmulated) {
         // We always register emulated objects, we need to always
         // use the streamer info to destroy them.
      }

      // Register the object for special handling in the destructor.
      if (p) {
         RegisterAddressInRepository("TClass::NewArray with placement",p,this);
      }
   } else {
      Error("NewArray with placement", "This cannot happen!");
   }

   return p;
}

//______________________________________________________________________________
void TClass::Destructor(void *obj, Bool_t dtorOnly)
{
   // Explicitly call destructor for object.

   // Do nothing if passed a null pointer.
   if (obj == 0) return;

   void* p = obj;

   if (dtorOnly && fDestructor) {
      // We have the destructor wrapper, use it.
      fDestructor(p);
   } else if ((!dtorOnly) && fDelete) {
      // We have the delete wrapper, use it.
      fDelete(p);
   } else if (fClassInfo) {
      // We have the dictionary but do not have the
      // destruct/delete wrapper, so the dictionary was
      // not generated by rootcint (it could have been
      // created by cint or by some external mechanism).
      // Let's have the interpreter call the destructor,
      // either the code will be in a loaded library,
      // or it will be interpreted, otherwise we fail
      // because there is no destructor code at all.
      if (dtorOnly) {
         gCint->ClassInfo_Destruct(fClassInfo,p);
      } else {
         gCint->ClassInfo_Delete(fClassInfo,p);
      }
   } else if (!fClassInfo && fCollectionProxy) {
      // There is no dictionary at all, so this is an emulated
      // class; however we do have the services of a collection proxy,
      // so this is an emulated STL class.
      fCollectionProxy->Destructor(p, dtorOnly);
   } else if (!fClassInfo && !fCollectionProxy) {
      // There is no dictionary at all and we do not have
      // the services of a collection proxy available, so
      // use the streamer info to approximate calling a
      // destructor.

      Bool_t inRepo = kTRUE;
      Bool_t verFound = kFALSE;

      // Was this object allocated through TClass?
      std::multiset<Version_t> knownVersions;
      std::multimap<void*, Version_t>::iterator iter = gObjectVersionRepository.find(p);
      if (iter == gObjectVersionRepository.end()) {
         // No, it wasn't, skip special version handling.
         //Error("Destructor2", "Attempt to delete unregistered object of class '%s' at address %p!", GetName(), p);
         inRepo = kFALSE;
      } else {
         //objVer = iter->second;
         for (; (iter != gObjectVersionRepository.end()) && (iter->first == p); ++iter) {
            Version_t ver = iter->second;
            knownVersions.insert(ver);
            if (ver == fClassVersion) {
               verFound = kTRUE;
            }
         }
      }

      if (!inRepo || verFound) {
         // The object was allocated using code for the same class version
         // as is loaded now.  We may proceed without worry.
         TVirtualStreamerInfo* si = GetStreamerInfo();
         if (si) {
            si->Destructor(p, dtorOnly);
         } else {
            Error("Destructor", "No streamer info available for class '%s' version %d at address %p, cannot destruct emulated object!", GetName(), fClassVersion, p);
            Error("Destructor", "length of fStreamerInfo is %d", fStreamerInfo->GetSize());
            Int_t i = fStreamerInfo->LowerBound();
            for (Int_t v = 0; v < fStreamerInfo->GetSize(); ++v, ++i) {
               Error("Destructor", "fStreamerInfo->At(%d): %p", i, fStreamerInfo->At(i));
               if (fStreamerInfo->At(i) != 0) {
                  Error("Destructor", "Doing Dump() ...");
                  ((TVirtualStreamerInfo*)fStreamerInfo->At(i))->Dump();
               }
            }
         }
      } else {
         // The loaded class version is not the same as the version of the code
         // which was used to allocate this object.  The best we can do is use
         // the TVirtualStreamerInfo to try to free up some of the allocated memory.
         Error("Destructor", "Loaded class %s version %d is not registered for addr %p", GetName(), fClassVersion, p);
#if 0
         TVirtualStreamerInfo* si = (TVirtualStreamerInfo*) fStreamerInfo->At(objVer);
         if (si) {
            si->Destructor(p, dtorOnly);
         } else {
            Error("Destructor2", "No streamer info available for class '%s' version %d, cannot destruct object at addr: %p", GetName(), objVer, p);
            Error("Destructor2", "length of fStreamerInfo is %d", fStreamerInfo->GetSize());
            Int_t i = fStreamerInfo->LowerBound();
            for (Int_t v = 0; v < fStreamerInfo->GetSize(); ++v, ++i) {
               Error("Destructor2", "fStreamerInfo->At(%d): %p", i, fStreamerInfo->At(i));
               if (fStreamerInfo->At(i) != 0) {
                  // Do some debugging output.
                  Error("Destructor2", "Doing Dump() ...");
                  ((TVirtualStreamerInfo*)fStreamerInfo->At(i))->Dump();
               }
            }
         }
#endif
      }

      if (inRepo && verFound && p) {
         UnregisterAddressInRepository("TClass::Destructor",p,this);
      }
   } else {
      Error("Destructor", "This cannot happen! (class %s)", GetName());
   }
}

//______________________________________________________________________________
void TClass::DeleteArray(void *ary, Bool_t dtorOnly)
{
   // Explicitly call operator delete[] for an array.

   // Do nothing if passed a null pointer.
   if (ary == 0) return;

   // Make a copy of the address.
   void* p = ary;

   if (fDeleteArray) {
      if (dtorOnly) {
         Error("DeleteArray", "Destructor only is not supported!");
      } else {
         // We have the array delete wrapper, use it.
         fDeleteArray(ary);
      }
   } else if (fClassInfo) {
      // We have the dictionary but do not have the
      // array delete wrapper, so the dictionary was
      // not generated by rootcint.  Let's try to
      // delete the array by having the interpreter
      // call the array delete operator, hopefully
      // the class library is loaded and there will be
      // a destructor we can call.
      R__LOCKGUARD2(gCINTMutex);
      gCint->ClassInfo_DeleteArray(GetClassInfo(),ary, dtorOnly);
   } else if (!fClassInfo && fCollectionProxy) {
      // There is no dictionary at all, so this is an emulated
      // class; however we do have the services of a collection proxy,
      // so this is an emulated STL class.
      fCollectionProxy->DeleteArray(ary, dtorOnly);
   } else if (!fClassInfo && !fCollectionProxy) {
      // There is no dictionary at all and we do not have
      // the services of a collection proxy available, so
      // use the streamer info to approximate calling the
      // array destructor.

      Bool_t inRepo = kTRUE;
      Bool_t verFound = kFALSE;

      // Was this array object allocated through TClass?
      std::multiset<Version_t> knownVersions;
      std::multimap<void*, Version_t>::iterator iter = gObjectVersionRepository.find(p);
      if (iter == gObjectVersionRepository.end()) {
         // No, it wasn't, we cannot know what to do.
         //Error("DeleteArray", "Attempt to delete unregistered array object, element type '%s', at address %p!", GetName(), p);
         inRepo = kFALSE;
      } else {
         for (; (iter != gObjectVersionRepository.end()) && (iter->first == p); ++iter) {
            Version_t ver = iter->second;
            knownVersions.insert(ver);
            if (ver == fClassVersion) {
               verFound = kTRUE;
            }
         }
      }

      if (!inRepo || verFound) {
         // The object was allocated using code for the same class version
         // as is loaded now.  We may proceed without worry.
         TVirtualStreamerInfo* si = GetStreamerInfo();
         if (si) {
            si->DeleteArray(ary, dtorOnly);
         } else {
            Error("DeleteArray", "No streamer info available for class '%s' version %d at address %p, cannot destruct object!", GetName(), fClassVersion, ary);
            Error("DeleteArray", "length of fStreamerInfo is %d", fStreamerInfo->GetSize());
            Int_t i = fStreamerInfo->LowerBound();
            for (Int_t v = 0; v < fStreamerInfo->GetSize(); ++v, ++i) {
               Error("DeleteArray", "fStreamerInfo->At(%d): %p", v, fStreamerInfo->At(i));
               if (fStreamerInfo->At(i)) {
                  Error("DeleteArray", "Doing Dump() ...");
                  ((TVirtualStreamerInfo*)fStreamerInfo->At(i))->Dump();
               }
            }
         }
      } else {
         // The loaded class version is not the same as the version of the code
         // which was used to allocate this array.  The best we can do is use
         // the TVirtualStreamerInfo to try to free up some of the allocated memory.
         Error("DeleteArray", "Loaded class version %d is not registered for addr %p", fClassVersion, p);



#if 0
         TVirtualStreamerInfo* si = (TVirtualStreamerInfo*) fStreamerInfo->At(objVer);
         if (si) {
            si->DeleteArray(ary, dtorOnly);
         } else {
            Error("DeleteArray", "No streamer info available for class '%s' version %d at address %p, cannot destruct object!", GetName(), objVer, ary);
            Error("DeleteArray", "length of fStreamerInfo is %d", fStreamerInfo->GetSize());
            Int_t i = fStreamerInfo->LowerBound();
            for (Int_t v = 0; v < fStreamerInfo->GetSize(); ++v, ++i) {
               Error("DeleteArray", "fStreamerInfo->At(%d): %p", v, fStreamerInfo->At(i));
               if (fStreamerInfo->At(i)) {
                  // Print some debugging info.
                  Error("DeleteArray", "Doing Dump() ...");
                  ((TVirtualStreamerInfo*)fStreamerInfo->At(i))->Dump();
               }
            }
         }
#endif


      }

      // Deregister the object for special handling in the destructor.
      if (inRepo && verFound && p) {
         UnregisterAddressInRepository("TClass::DeleteArray",p,this);
      }
   } else {
      Error("DeleteArray", "This cannot happen! (class '%s')", GetName());
   }
}

//______________________________________________________________________________
void TClass::SetClassVersion(Version_t version) 
{ 
   // Private function.  Set the class version for the 'class' represented by
   // this TClass object.  See the public interface: 
   //    ROOT::ResetClassVersion 
   // defined in TClassTable.cxx
   //
   // Note on class version numbers:
   //   If no class number has been specified, TClass::GetVersion will return -1
   //   The Class Version 0 request the whole object to be transient
   //   The Class Version 1, unless specified via ClassDef indicates that the
   //      I/O should use the TClass checksum to distinguish the layout of the class   
   
   fClassVersion = version; 
   fCurrentInfo = 0; 
}

//______________________________________________________________________________
void TClass::SetCurrentStreamerInfo(TVirtualStreamerInfo *info)
{
   // Set pointer to current TVirtualStreamerInfo

   fCurrentInfo = info;
}

//______________________________________________________________________________
Int_t TClass::Size() const
{
   // Return size of object of this class.

   if (fSizeof!=-1) return fSizeof;
   if (fCollectionProxy) return fCollectionProxy->Sizeof();
   if (fClassInfo) return gCint->ClassInfo_Size(GetClassInfo());
   return GetStreamerInfo()->GetSize();
}

//______________________________________________________________________________
TClass *TClass::Load(TBuffer &b)
{
   // Load class description from I/O buffer and return class object.

   UInt_t maxsize = 256;
   char *s = new char[maxsize];

   Int_t pos = b.Length();

   b.ReadString(s, maxsize); // Reads at most maxsize - 1 characters, plus null at end.
   while (strlen(s) == (maxsize - 1)) {
      // The classname is too large, try again with a large buffer.
      b.SetBufferOffset(pos);
      maxsize = 2*maxsize;
      delete [] s;
      s = new char[maxsize];
      b.ReadString(s, maxsize); // Reads at most maxsize - 1 characters, plus null at end.
   }

   TClass *cl = TClass::GetClass(s, kTRUE);
   if (!cl)
      ::Error("TClass::Load", "dictionary of class %s not found", s);

   delete [] s;
   return cl;
}

//______________________________________________________________________________
void TClass::Store(TBuffer &b) const
{
   // Store class description on I/O buffer.

   b.WriteString(GetName());
}

//______________________________________________________________________________
TClass *ROOT::CreateClass(const char *cname, Version_t id,
                          const type_info &info, TVirtualIsAProxy *isa,
                          ShowMembersFunc_t show,
                          const char *dfil, const char *ifil,
                          Int_t dl, Int_t il)
{
   // Global function called by a class' static Dictionary() method
   // (see the ClassDef macro).

   // When called via TMapFile (e.g. Update()) make sure that the dictionary
   // gets allocated on the heap and not in the mapped file.
   if (gMmallocDesc) {
      void *msave  = gMmallocDesc;
      gMmallocDesc = 0;
      TClass *cl   = new TClass(cname, id, info, isa, show, dfil, ifil, dl, il);
      gMmallocDesc = msave;
      return cl;
   }
   return new TClass(cname, id, info, isa, show, dfil, ifil, dl, il);
}

//______________________________________________________________________________
TClass *ROOT::CreateClass(const char *cname, Version_t id,
                          const char *dfil, const char *ifil,
                          Int_t dl, Int_t il)
{
   // Global function called by a class' static Dictionary() method
   // (see the ClassDef macro).

   // When called via TMapFile (e.g. Update()) make sure that the dictionary
   // gets allocated on the heap and not in the mapped file.
   if (gMmallocDesc) {
      void *msave  = gMmallocDesc;
      gMmallocDesc = 0;
      TClass *cl   = new TClass(cname, id, dfil, ifil, dl, il);
      gMmallocDesc = msave;
      return cl;
   }
   return new TClass(cname, id, dfil, ifil, dl, il);
}

//______________________________________________________________________________
TClass::ENewType TClass::IsCallingNew()
{
   // Static method returning the defConstructor flag passed to TClass::New().
   // New type is either:
   //   TClass::kRealNew  - when called via plain new
   //   TClass::kClassNew - when called via TClass::New()
   //   TClass::kDummyNew - when called via TClass::New() but object is a dummy,
   //                       in which case the object ctor might take short cuts

   return fgCallingNew;
}

//______________________________________________________________________________
Bool_t TClass::IsLoaded() const
{
   // Return true if the shared library of this class is currently in the a
   // process's memory.  Return false, after the shared library has been
   // unloaded or if this is an 'emulated' class created from a file's StreamerInfo.

   return (GetImplFileLine()>=0 && !TestBit(kUnloaded));
}

//______________________________________________________________________________
Bool_t  TClass::IsStartingWithTObject() const
{
   // Returns true if this class inherits from TObject and if the start of
   // the TObject parts is at the very beginning of the objects.
   // Concretly this means that the following code is proper for this class:
   //     ThisClass *ptr;
   //     void *void_ptr = (void)ptr;
   //     TObject *obj = (TObject*)void_ptr;
   // This code would be wrong if 'ThisClass' did not inherit 'first' from
   // TObject.

   if (fProperty==(-1)) Property();
   return TestBit(kStartWithTObject);
}

//______________________________________________________________________________
Bool_t  TClass::IsTObject() const
{
   // Return kTRUE is the class inherits from TObject.

   if (fProperty==(-1)) Property();
   return TestBit(kIsTObject);
}

//______________________________________________________________________________
Bool_t  TClass::IsForeign() const
{
   // Return kTRUE is the class is Foreign (the class does not have a Streamer method).

   if (fProperty==(-1)) Property();
   return TestBit(kIsForeign);
}

//______________________________________________________________________________
void TClass::PostLoadCheck()
{
   // Do the initialization that can only be done after the CINT dictionary has
   // been fully populated and can not be delayed efficiently.

   // In the case of a Foreign class (loaded class without a Streamer function)
   // we reset fClassVersion to be -1 so that the current TVirtualStreamerInfo will not
   // be confused with a previously loaded streamerInfo.

   if (IsLoaded() && fClassInfo && fClassVersion==1 /*&& fStreamerInfo
       && fStreamerInfo->At(1)*/ && IsForeign() )
   {
      SetClassVersion(-1);
   }
   else if (IsLoaded() && fClassInfo && fStreamerInfo && (!IsForeign()||fClassVersion>1) )
   {
      TVirtualStreamerInfo *info = (TVirtualStreamerInfo*)(fStreamerInfo->At(fClassVersion));
      // Here we need to check whether this TVirtualStreamerInfo (which presumably has been
      // loaded from a file) is consistent with the definition in the library we just loaded.
      // BuildCheck is not appropriate here since it check a streamerinfo against the
      // 'current streamerinfo' which, at time point, would be the same as 'info'!
      if (info && GetListOfDataMembers() && !GetCollectionProxy()
          && (info->GetCheckSum()!=GetCheckSum() && info->GetCheckSum()!=GetCheckSum(1) && info->GetCheckSum()!=GetCheckSum(2)))
      {
         Bool_t warn = ! TestBit(kWarned);
         if (warn && info->GetOldVersion()<=2) {
            // Names of STL base classes was modified in vers==3. Allocators removed
            //
            TIter nextBC(GetListOfBases());
            TBaseClass *bc;
            while ((bc=(TBaseClass*)nextBC()))
            {if (TClassEdit::IsSTLCont(bc->GetName())) warn = kFALSE;}
         }

         if (warn) {
            if (info->GetOnFileClassVersion()==1 && fClassVersion>1) {
               Warning("PostLoadCheck","\n\
   The class %s transitioned from not having a specified class version\n\
   to having a specified class version (the current class version is %d).\n\
   However too many different non-versioned layouts of the class have\n\
   already been loaded so far.  To work around this problem you can\n\
   load fewer 'old' file in the same ROOT session or load the C++ library\n\
   describing the class %s before opening the files or increase the version\n\
   number of the class for example ClassDef(%s,%d).\n\
   Do not try to write objects with the current class definition,\n\
   the files might not be readable.\n",
                       GetName(), fClassVersion, GetName(), GetName(), fStreamerInfo->GetLast()+1);
            } else {
               Warning("PostLoadCheck","\n\
   The StreamerInfo version %d for the class %s which was read\n\
   from a file previously opened has the same version as the active class\n\
   but a different checksum. You should update the version to ClassDef(%s,%d).\n\
   Do not try to write objects with the current class definition,\n\
   the files will not be readable.\n"
                       , fClassVersion, GetName(), GetName(), fStreamerInfo->GetLast()+1);
            }
            info->CompareContent(this,0,kTRUE,kTRUE);
            SetBit(kWarned);
         }
      }
   }
}

//______________________________________________________________________________
Long_t TClass::Property() const
{
   // Set TObject::fBits and fStreamerType to cache information about the
   // class.  The bits are
   //    kIsTObject : the class inherits from TObject
   //    kStartWithTObject:  TObject is the left-most class in the inheritance tree
   //    kIsForeign : the class doe not have a Streamer method
   // The value of fStreamerType are
   //    kTObject : the class inherits from TObject
   //    kForeign : the class does not have a Streamer method
   //    kInstrumented: the class does have a Streamer method
   //    kExternal: the class has a free standing way of streaming itself
   //    kEmulated: the class is missing its shared library.

   if (fProperty!=(-1)) return fProperty;

   Long_t dummy;
   TClass *kl = const_cast<TClass*>(this);

   kl->fStreamerType = kNone;

   if (InheritsFrom(TObject::Class())) {
      kl->SetBit(kIsTObject);

      // Is it DIRECT inheritance from TObject?
      Int_t delta = kl->GetBaseClassOffset(TObject::Class());
      if (delta==0) kl->SetBit(kStartWithTObject);

      kl->fStreamerType  = kTObject;
   }

   if (fClassInfo) {

      kl->fProperty = gCint->ClassInfo_Property(fClassInfo);

      if (!gCint->ClassInfo_HasMethod(fClassInfo,"Streamer") ||
          !gCint->ClassInfo_IsValidMethod(fClassInfo,"Streamer","TBuffer&",&dummy) ) {

         kl->SetBit(kIsForeign);
         kl->fStreamerType  = kForeign;

      } else if ( kl->fStreamerType == kNone ) {
         if ( gCint->ClassInfo_FileName(fClassInfo) 
             && strcmp( gCint->ClassInfo_FileName(fClassInfo),"{CINTEX dictionary translator}")==0) {
            kl->SetBit(kIsForeign);
         }
         kl->fStreamerType  = kInstrumented;
      }

      if (fStreamer)   kl->fStreamerType  = kExternal;

   } else {

      if (fStreamer)   kl->fStreamerType  = kExternal;

      kl->fStreamerType |= kEmulated;

      return 0;
   }

   return fProperty;
}

//_____________________________________________________________________________
void TClass::SetCollectionProxy(const ROOT::TCollectionProxyInfo &info)
{
   // Create the collection proxy object (and the streamer object) from
   // using the information in the TCollectionProxyInfo.

   delete fCollectionProxy;

   // We can not use GetStreamerInfo() instead of TVirtualStreamerInfo::Factory()
   // because GetStreamerInfo call TStreamerInfo::Build which need to have fCollectionProxy
   // set correctly.

   TVirtualCollectionProxy *p = TVirtualStreamerInfo::Factory()->GenExplicitProxy(info,this);
   fCollectionProxy = p;

   AdoptStreamer(TVirtualStreamerInfo::Factory()->GenExplicitClassStreamer(info,this));
}

//______________________________________________________________________________
void TClass::SetContextMenuTitle(const char *title)
{
   // Change (i.e. set) the title of the TNamed.

   fContextMenuTitle = title;
}

//______________________________________________________________________________
void TClass::SetGlobalIsA(IsAGlobalFunc_t func)
{
   // This function installs a global IsA function for this class.
   // The global IsA function will be used if there is no local IsA function (fIsA)
   //
   // A global IsA function has the signature:
   //
   //    TClass *func( TClass *cl, const void *obj);
   //
   // 'cl' is a pointer to the  TClass object that corresponds to the
   // 'pointer type' used to retrieve the value 'obj'
   //
   //  For example with:
   //    TNamed * m = new TNamed("example","test");
   //    TObject* o = m
   // and
   //    the global IsA function would be called with TObject::Class() as
   //    the first parameter and the exact numerical value in the pointer
   //    'o'.
   //
   //  In other word, inside the global IsA function. it is safe to C-style
   //  cast the value of 'obj' into a pointer to the class described by 'cl'.

   fGlobalIsA = func;
}

//______________________________________________________________________________
void TClass::SetUnloaded()
{
   // Call this method to indicate that the shared library containing this
   // class's code has been removed (unloaded) from the process's memory

   delete fIsA; fIsA = 0;
   // Disable the autoloader while calling SetClassInfo, to prevent
   // the library from being reloaded!
   int autoload_old = gCint->SetClassAutoloading(0);
   gInterpreter->SetClassInfo(this,kTRUE);
   gCint->SetClassAutoloading(autoload_old);
   fDeclFileName = 0;
   fDeclFileLine = 0;
   fImplFileName = 0;
   fImplFileLine = 0;
   fTypeInfo     = 0;

   if (fMethod) {
      fMethod->Delete();
      delete fMethod;
      fMethod=0;
   }
  
   SetBit(kUnloaded);
}

//______________________________________________________________________________
TVirtualStreamerInfo *TClass::SetStreamerInfo(Int_t /*version*/, const char * /*info*/)
{
   // Info is a string describing the names and types of attributes
   // written by the class Streamer function.
   // If info is an empty string (when called by TObject::StreamerInfo)
   // the default Streamer info string is build. This corresponds to
   // the case of an automatically generated Streamer.
   // In case of user defined Streamer function, it is the user responsability
   // to implement a StreamerInfo function (override TObject::StreamerInfo).
   // The user must call IsA()->SetStreamerInfo(info) from this function.

   // info is specified, nothing to do, except that we should verify
   // that it contains a valid descriptor.

/*
   TDataMember *dm;
   Int_t nch = strlen(info);
   Bool_t update = kTRUE;
   if (nch != 0) {
      //decode strings like "TObject;TAttLine;fA;fB;Int_t i,j,k;"
      char *save, *temp, *blank, *colon, *comma;
      save = new char[10000];
      temp = save;
      strcpy(temp,info);
      //remove heading and trailing blanks
      while (*temp == ' ') temp++;
      while (save[nch-1] == ' ') {nch--; save[nch] = 0;}
      if (nch == 0) {delete [] save; return;}
      if (save[nch-1] != ';') {save[nch] = ';'; save[nch+1] = 0;}
      //remove blanks around , or ;
      while ((blank = strstr(temp,"; "))) strcpy(blank+1,blank+2);
      while ((blank = strstr(temp," ;"))) strcpy(blank,  blank+1);
      while ((blank = strstr(temp,", "))) strcpy(blank+1,blank+2);
      while ((blank = strstr(temp," ,"))) strcpy(blank,  blank+1);
      while ((blank = strstr(temp,"  "))) strcpy(blank,  blank+1);
      //loop on tokens separated by ;
      char *final = new char[1000];
      char token[100];
      while ((colon=strchr(temp,';'))) {
         *colon = 0;
         strcpy(token,temp);
         blank = strchr(token,' ');
         if (blank) {
            *blank = 0;
            if (!gROOT->GetType(token)) {
               Error("SetStreamerInfo","Illegal type: %s in %s",token,info);
               return;
            }
            while (blank) {
               strcat(final,token);
               strcat(final," ");
               comma = strchr(blank+1,','); if (comma) *comma=0;
               strcat(final,blank+1);
               strcat(final,";");
               blank = comma;
            }

         } else {
            if (TClass::GetClass(token,update)) {
               //a class name
               strcat(final,token); strcat(final,";");
            } else {
               //a data member name
               dm = (TDataMember*)GetListOfDataMembers()->FindObject(token);
               if (dm) {
                  strcat(final,dm->GetFullTypeName());
                  strcat(final," ");
                  strcat(final,token); strcat(final,";");
               } else {
                  Error("SetStreamerInfo","Illegal name: %s in %s",token,info);
                  return;
               }
            }
            update = kFALSE;
         }
         temp = colon+1;
         if (*temp == 0) break;
      }
 ////     fStreamerInfo = final;
      delete [] final;
      delete [] save;
      return;
   }

   //info is empty. Let's build the default Streamer descriptor

   char *temp = new char[10000];
   temp[0] = 0;
   char local[100];

   //add list of base classes
   TIter nextb(GetListOfBases());
   TBaseClass *base;
   while ((base = (TBaseClass*) nextb())) {
      sprintf(local,"%s;",base->GetName());
      strcat(temp,local);
   }

   //add list of data members and types
   TIter nextd(GetListOfDataMembers());
   while ((dm = (TDataMember *) nextd())) {
      if (dm->IsEnum()) continue;
      if (!dm->IsPersistent()) continue;
      Long_t property = dm->Property();
      if (property & kIsStatic) continue;
      TClass *acl = TClass::GetClass(dm->GetTypeName(),update);
      update = kFALSE;
      if (acl) {
         if (acl->GetClassVersion() == 0) continue;
      }

      // dm->GetArrayIndex() returns an empty string if it does not
      // applies
      const char * index = dm->GetArrayIndex();
      if (strlen(index)==0)
         sprintf(local,"%s %s;",dm->GetFullTypeName(),dm->GetName());
      else
         sprintf(local,"%s %s[%s];",dm->GetFullTypeName(),dm->GetName(),index);
      strcat(temp,local);
   }
   //fStreamerInfo = temp;
   delete [] temp;
*/
   return 0;
}

//______________________________________________________________________________
UInt_t TClass::GetCheckSum(UInt_t code) const
{
   // Compute and/or return the class check sum.
   // The class ckecksum is used by the automatic schema evolution algorithm
   // to uniquely identify a class version.
   // The check sum is built from the names/types of base classes and
   // data members.
   // Algorithm from Victor Perevovchikov (perev@bnl.gov).
   //
   // if code==1 data members of type enum are not counted in the checksum
   // if code==2 return the checksum of data members and base classes, not including the ranges and array size found in comments.  
   //            This is needed for backward compatibility.
   //
   // WARNING: this function must be kept in sync with TClass::GetCheckSum.
   // They are both used to handle backward compatibility and should both return the same values.
   // TStreamerInfo uses the information in TStreamerElement while TClass uses the information
   // from TClass::GetListOfBases and TClass::GetListOfDataMembers.

   if (fCheckSum && code == 0) return fCheckSum;

   UInt_t id = 0;

   int il;
   TString name = GetName();
   TString type;
   il = name.Length();
   for (int i=0; i<il; i++) id = id*3+name[i];

   TList *tlb = ((TClass*)this)->GetListOfBases();
   if (tlb) {   // Loop over bases

      TIter nextBase(tlb);

      TBaseClass *tbc=0;
      while((tbc=(TBaseClass*)nextBase())) {
         name = tbc->GetName();
         il = name.Length();
         for (int i=0; i<il; i++) id = id*3+name[i];
      }/*EndBaseLoop*/
   }
   TList *tlm = ((TClass*)this)->GetListOfDataMembers();
   if (tlm) {   // Loop over members
      TIter nextMemb(tlm);
      TDataMember *tdm=0;
      Long_t prop = 0;
      while((tdm=(TDataMember*)nextMemb())) {
         if (!tdm->IsPersistent())        continue;
         //  combine properties
         prop = (tdm->Property());
         TDataType* tdt = tdm->GetDataType();
         if (tdt) prop |= tdt->Property();

         if ( prop&kIsStatic)             continue;
         name = tdm->GetName(); il = name.Length();
         if ( (code != 1) && prop&kIsEnum) id = id*3 + 1;

         int i;
         for (i=0; i<il; i++) id = id*3+name[i];
         type = tdm->GetFullTypeName();
         if (TClassEdit::IsSTLCont(type))
            type = TClassEdit::ShortType( type, TClassEdit::kDropStlDefault );

         il = type.Length();
         for (i=0; i<il; i++) id = id*3+type[i];

         int dim = tdm->GetArrayDim();
         if (prop&kIsArray) {
            for (int ii=0;ii<dim;ii++) id = id*3+tdm->GetMaxIndex(ii);
         }
         if (code != 2) {
            const char *left = strstr(tdm->GetTitle(),"[");
            if (left) {
               const char *right = strstr(left,"]");
               if (right) {
                  ++left;
                  while (left != right) {
                     id = id*3 + *left;
                     ++left;
                  }
               }
            }
         }
      }/*EndMembLoop*/
   }
   if (code==0) fCheckSum = id;
   return id;
}

//______________________________________________________________________________
void TClass::AdoptReferenceProxy(TVirtualRefProxy* proxy)
{
   // Adopt the Reference proxy pointer to indicate that this class
   // represents a reference.
   // When a new proxy is adopted, the old one is deleted.

   if ( fRefProxy )  {
      fRefProxy->Release();
   }
   fRefProxy = proxy;
   if ( fRefProxy )  {
      fRefProxy->SetClass(this);
   }
}

//______________________________________________________________________________
void TClass::AdoptMemberStreamer(const char *name, TMemberStreamer *p)
{
   // Adopt the TMemberStreamer pointer to by p and use it to Stream non basic
   // member name.

   if (!fRealData) return;
   TIter next(fRealData);
   TRealData *rd;
   while ((rd = (TRealData*)next())) {
      if (strcmp(rd->GetName(),name) == 0) {
         // If there is a TStreamerElement that took a pointer to the
         // streamer we should inform it!
         rd->AdoptStreamer(p);
         break;
      }
   }

//  NOTE: This alternative was proposed but not is not used for now,
//  One of the major difference with the code above is that the code below
//  did not require the RealData to have been built
//    if (!fData) return;
//    const char *n = name;
//    while (*n=='*') n++;
//    TString ts(n);
//    int i = ts.Index("[");
//    if (i>=0) ts.Remove(i,999);
//    TDataMember *dm = (TDataMember*)fData->FindObject(ts.Data());
//    if (!dm) {
//       Warning("SetStreamer","Can not find member %s::%s",GetName(),name);
//       return;
//    }
//    dm->SetStreamer(p);
   return;
}

//______________________________________________________________________________
void TClass::SetMemberStreamer(const char *name, MemberStreamerFunc_t p)
{
   // Install a new member streamer (p will be copied).

   AdoptMemberStreamer(name,new TMemberStreamer(p));
}

//______________________________________________________________________________
Int_t TClass::ReadBuffer(TBuffer &b, void *pointer, Int_t version, UInt_t start, UInt_t count)
{
   // Function called by the Streamer functions to deserialize information
   // from buffer b into object at p.
   // This function assumes that the class version and the byte count information
   // have been read.
   //   version  is the version number of the class
   //   start    is the starting position in the buffer b
   //   count    is the number of bytes for this object in the buffer

   return b.ReadClassBuffer(this,pointer,version,start,count);
}

//______________________________________________________________________________
Int_t TClass::ReadBuffer(TBuffer &b, void *pointer)
{
   // Function called by the Streamer functions to deserialize information
   // from buffer b into object at p.

   return b.ReadClassBuffer(this,pointer);
}

//______________________________________________________________________________
Int_t TClass::WriteBuffer(TBuffer &b, void *pointer, const char * /*info*/)
{
   // Function called by the Streamer functions to serialize object at p
   // to buffer b. The optional argument info may be specified to give an
   // alternative StreamerInfo instead of using the default StreamerInfo
   // automatically built from the class definition.
   // For more information, see class TVirtualStreamerInfo.

   b.WriteClassBuffer(this,pointer);
   return 0;
}

//______________________________________________________________________________
void TClass::Streamer(void *object, TBuffer &b, const TClass *onfile_class) const
{
   // Stream object of this class to or from buffer.

   switch (fStreamerType) {

      case kExternal:
      case kExternal|kEmulated: 
      {
         //There is special streamer for the class
         TClassStreamer *streamer = GetStreamer();
         streamer->SetOnFileClass( onfile_class );
         (*streamer)(b,object);

         return;
      }

      case kTObject:
      {
         if (!fInterStreamer) {
            CalculateStreamerOffset();
         }
         TObject *tobj = (TObject*)((Long_t)object + fOffsetStreamer);
         tobj->Streamer(b);
      }
      return;

      case kTObject|kEmulated : {
         b.ReadClassEmulated(this, object, onfile_class);
      }
      return;

      case kInstrumented: // Instrumented class with a library
      {
         CallFunc_t *func = (CallFunc_t*)fInterStreamer;

         if (!func)  {
            func  = gCint->CallFunc_Factory();
            gCint->CallFunc_SetFuncProto(func,fClassInfo,"Streamer","TBuffer&",&fOffsetStreamer);
            fInterStreamer = func;
         } else {
            // Reset the argument list!
            gCint->CallFunc_SetArgs(func,"");
         }

         // set arguments
         gCint->CallFunc_SetArg(func,(Long_t)&b);
         // call function
         gCint->CallFunc_Exec(func,(char*)((Long_t)object + fOffsetStreamer) );

      }
      return;

      case kForeign:
      case kForeign|kEmulated:
      case kInstrumented|kEmulated:
      case kEmulated:
      {
         if (b.IsReading()) {
            b.ReadClassBuffer(this, object, onfile_class);
            //ReadBuffer (b, object);
         } else {
            //WriteBuffer(b, object);
            b.WriteClassBuffer(this, object);
         }
      }
      return;

      default:
      {
         if (fProperty==(-1)) {
            Property();
            Streamer(object,b);
         } else {
            Fatal("Streamer", "fStreamerType not properly initialized (%d)", fStreamerType);
         }
      }
   }
}

//______________________________________________________________________________
void TClass::AdoptStreamer(TClassStreamer *str)
{
   // Adopt a TClassStreamer object.  Ownership is transfered to this TClass
   // object.

//    // This code can be used to quickly test the STL Emulation layer
//    Int_t k = TClassEdit::IsSTLCont(GetName());
//    if (k==1||k==-1) { delete str; return; }

   if (fStreamer) delete fStreamer;
   if (str) {
      fStreamerType = kExternal | ( fStreamerType&kEmulated );
      fStreamer = str;
   } else if (fStreamer) {
      // Case where there was a custom streamer and it is hereby removed,
      // we need to reset fStreamerType
      fStreamer = str;
      fStreamerType = kNone;
      fProperty = -1;
      Property();
   }
}

//______________________________________________________________________________
void TClass::SetNew(ROOT::NewFunc_t newFunc)
{
   // Install a new wrapper around 'new'.

   fNew = newFunc;
}

//______________________________________________________________________________
void TClass::SetNewArray(ROOT::NewArrFunc_t newArrayFunc)
{
   // Install a new wrapper around 'new []'.

   fNewArray = newArrayFunc;
}

//______________________________________________________________________________
void TClass::SetDelete(ROOT::DelFunc_t deleteFunc)
{
   // Install a new wrapper around 'delete'.

   fDelete = deleteFunc;
}

//______________________________________________________________________________
void TClass::SetDeleteArray(ROOT::DelArrFunc_t deleteArrayFunc)
{
   // Install a new wrapper around 'delete []'.

   fDeleteArray = deleteArrayFunc;
}

//______________________________________________________________________________
void TClass::SetDestructor(ROOT::DesFunc_t destructorFunc)
{
   // Install a new wrapper around the destructor.

   fDestructor = destructorFunc;
}

//______________________________________________________________________________
void TClass::SetDirectoryAutoAdd(ROOT::DirAutoAdd_t autoAddFunc)
{
   // Install a new wrapper around the directory auto add function..
   // The function autoAddFunc has the signature void (*)(void *obj, TDirectory dir)
   // and should register 'obj' to the directory if dir is not null
   // and unregister 'obj' from its current directory if dir is null

   fDirAutoAdd = autoAddFunc;
}

//______________________________________________________________________________
TVirtualStreamerInfo *TClass::FindStreamerInfo(UInt_t checksum) const
{
   // Find the TVirtualStreamerInfo in the StreamerInfos corresponding to checksum

   Int_t ninfos = fStreamerInfo->GetEntriesFast()-1;
   for (Int_t i=-1;i<ninfos;++i) {
      // TClass::fStreamerInfos has a lower bound not equal to 0,
      // so we have to use At and should not use UncheckedAt
      TVirtualStreamerInfo *info = (TVirtualStreamerInfo*)fStreamerInfo->UncheckedAt(i);
      if (info && info->GetCheckSum() == checksum) {
         // R__ASSERT(i==info->GetClassVersion() || (i==-1&&info->GetClassVersion()==1));
         return info;
      }
   }
   return 0;
}

//______________________________________________________________________________
TVirtualStreamerInfo *TClass::FindStreamerInfo(TObjArray* arr, UInt_t checksum) const
{
   // Find the TVirtualStreamerInfo in the StreamerInfos corresponding to checksum

   Int_t ninfos = arr->GetEntriesFast()-1;
   for (Int_t i=-1;i<ninfos;i++) {
      // TClass::fStreamerInfos has a lower bound not equal to 0,
      // so we have to use At and should not use UncheckedAt
      TVirtualStreamerInfo *info = (TVirtualStreamerInfo*)arr->UncheckedAt(i);
      if (!info) continue;
      if (info->GetCheckSum() == checksum) {
         R__ASSERT(i==info->GetClassVersion() || (i==-1&&info->GetClassVersion()==1));
         return info;
      }
   }
   return 0;
}

//______________________________________________________________________________
TVirtualStreamerInfo *TClass::GetConversionStreamerInfo( const char* classname, Int_t version ) const
{
   // Return a Conversion StreamerInfo from the class 'classname' for version number 'version' to this class, if any.
   
   TClass *cl = TClass::GetClass( classname );
   if( !cl )
      return 0;
   return GetConversionStreamerInfo( cl, version );
}

//______________________________________________________________________________
TVirtualStreamerInfo *TClass::GetConversionStreamerInfo( const TClass* cl, Int_t version ) const
{
   // Return a Conversion StreamerInfo from the class represened by cl for version number 'version' to this class, if any.

   //----------------------------------------------------------------------------
   // Check if the classname was specified correctly
   //----------------------------------------------------------------------------
   if( !cl )
      return 0;

   if( cl == this )
      return GetStreamerInfo( version );

   //----------------------------------------------------------------------------
   // Check if we already have it
   //----------------------------------------------------------------------------
   TObjArray* arr = 0;
   if (fConversionStreamerInfo) {
      std::map<std::string, TObjArray*>::iterator it;

      it = fConversionStreamerInfo->find( cl->GetName() );

      if( it != fConversionStreamerInfo->end() ) {
         arr = it->second;
      }

      if( version > -1 && version < arr->GetSize() && arr->At( version ) )
         return (TVirtualStreamerInfo*) arr->At( version );
   }

   //----------------------------------------------------------------------------
   // We don't have the streamer info so find it in other class
   //----------------------------------------------------------------------------
   TObjArray *clSI = cl->GetStreamerInfos();
   TVirtualStreamerInfo* info = 0;
   if( version > -1 && version < clSI->GetSize() )
      info = (TVirtualStreamerInfo*)clSI->At( version );

   if( !info )
      return 0;

   //----------------------------------------------------------------------------
   // We have the right info so we need to clone it to create new object with
   // non artificial streamer elements and we should build it for current class
   //----------------------------------------------------------------------------
   info = (TVirtualStreamerInfo*)info->Clone();

   if( !info->BuildFor( this ) ) {
      delete info;
      return 0;
   }

   if (!info->GetOffsets()) {
      // Streamer info has not been compiled, but exists.
      // Therefore it was read in from a file and we have to do schema evolution?
      // Or it didn't have a dictionary before, but does now?
      info->BuildOld();
   }
   if (info->IsOptimized() && !TVirtualStreamerInfo::CanOptimize()) {
      // Undo optimization if the global flag tells us to.
      info->Compile();
   }
   
   //----------------------------------------------------------------------------
   // Cache this treamer info
   //----------------------------------------------------------------------------
   if (!arr) {
      arr = new TObjArray(version+10, -1);
      if (!fConversionStreamerInfo) {
         fConversionStreamerInfo = new std::map<std::string, TObjArray*>();
      }
      (*fConversionStreamerInfo)[cl->GetName()] = arr;
   }
   arr->AddAtAndExpand( info, info->GetClassVersion() );
   return info;
}

//______________________________________________________________________________
TVirtualStreamerInfo *TClass::FindConversionStreamerInfo( const char* classname, UInt_t checksum ) const
{
   // Return a Conversion StreamerInfo from the class 'classname' for the layout represented by 'checksum' to this class, if any.

   TClass *cl = TClass::GetClass( classname );
   if( !cl )
      return 0;
   return FindConversionStreamerInfo( cl, checksum );
}

//______________________________________________________________________________
TVirtualStreamerInfo *TClass::FindConversionStreamerInfo( const TClass* cl, UInt_t checksum ) const
{
   // Return a Conversion StreamerInfo from the class represened by cl for the layout represented by 'checksum' to this class, if any.

   //---------------------------------------------------------------------------
   // Check if the classname was specified correctly
   //---------------------------------------------------------------------------
   if( !cl )
      return 0;

   if( cl == this )
      return FindStreamerInfo( checksum );

   //----------------------------------------------------------------------------
   // Check if we already have it
   //----------------------------------------------------------------------------
   TObjArray* arr = 0;
   TVirtualStreamerInfo* info = 0;
   if (fConversionStreamerInfo) {
      std::map<std::string, TObjArray*>::iterator it;
      
      it = fConversionStreamerInfo->find( cl->GetName() );
      
      if( it != fConversionStreamerInfo->end() ) {
         arr = it->second;
      }
      info = FindStreamerInfo( arr, checksum );
   }

   if( info )
      return info;

   //----------------------------------------------------------------------------
   // Get it from the foreign class
   //----------------------------------------------------------------------------
   info = cl->FindStreamerInfo( checksum );

   if( !info )
      return 0;

   //----------------------------------------------------------------------------
   // We have the right info so we need to clone it to create new object with
   // non artificial streamer elements and we should build it for current class
   //----------------------------------------------------------------------------
   info = (TVirtualStreamerInfo*)info->Clone();
   if( !info->BuildFor( this ) ) {
      delete info;
      return 0;
   }

   if (!info->GetOffsets()) {
      // Streamer info has not been compiled, but exists.
      // Therefore it was read in from a file and we have to do schema evolution?
      // Or it didn't have a dictionary before, but does now?
      info->BuildOld();
   }
   if (info->IsOptimized() && !TVirtualStreamerInfo::CanOptimize()) {
      // Undo optimization if the global flag tells us to.
      info->Compile();
   }
   
   //----------------------------------------------------------------------------
   // Cache this treamer info
   //----------------------------------------------------------------------------
   if (!arr) {
      arr = new TObjArray(16, -1);
      if (!fConversionStreamerInfo) {
         fConversionStreamerInfo = new std::map<std::string, TObjArray*>();
      }
      (*fConversionStreamerInfo)[cl->GetName()] = arr;
   }
   arr->AddAtAndExpand( info, info->GetClassVersion() );

   return info;
}

//______________________________________________________________________________
Bool_t TClass::HasDefaultConstructor() const
{
   // Return true if we have access to a default constructor.

   if (fNew) return kTRUE;

   if (GetClassInfo()) {
      return gCint->ClassInfo_HasDefaultConstructor(GetClassInfo());
   }
   if (fCollectionProxy) {
      return kTRUE;
   }
   if (fCurrentInfo) {
      // Emulated class, we know how to construct them via the TStreamerInfo
      return kTRUE;
   }
   return kFALSE;
}

//______________________________________________________________________________
ROOT::NewFunc_t TClass::GetNew() const
{
   // Return the wrapper around new ThisClass().

   return fNew;
}

//______________________________________________________________________________
ROOT::NewArrFunc_t TClass::GetNewArray() const
{
   // Return the wrapper around new ThisClass[].

   return fNewArray;
}

//______________________________________________________________________________
ROOT::DelFunc_t TClass::GetDelete() const
{
   // Return the wrapper around delete ThiObject.

   return fDelete;
}

//______________________________________________________________________________
ROOT::DelArrFunc_t TClass::GetDeleteArray() const
{
   // Return the wrapper around delete [] ThiObject.

   return fDeleteArray;
}

//______________________________________________________________________________
ROOT::DesFunc_t TClass::GetDestructor() const
{
   // Return the wrapper around the destructor

   return fDestructor;
}

//______________________________________________________________________________
ROOT::DirAutoAdd_t TClass::GetDirectoryAutoAdd() const
{
   // Return the wrapper around the directory auto add function.

   return fDirAutoAdd;
}

 TClass.cxx:1
 TClass.cxx:2
 TClass.cxx:3
 TClass.cxx:4
 TClass.cxx:5
 TClass.cxx:6
 TClass.cxx:7
 TClass.cxx:8
 TClass.cxx:9
 TClass.cxx:10
 TClass.cxx:11
 TClass.cxx:12
 TClass.cxx:13
 TClass.cxx:14
 TClass.cxx:15
 TClass.cxx:16
 TClass.cxx:17
 TClass.cxx:18
 TClass.cxx:19
 TClass.cxx:20
 TClass.cxx:21
 TClass.cxx:22
 TClass.cxx:23
 TClass.cxx:24
 TClass.cxx:25
 TClass.cxx:26
 TClass.cxx:27
 TClass.cxx:28
 TClass.cxx:29
 TClass.cxx:30
 TClass.cxx:31
 TClass.cxx:32
 TClass.cxx:33
 TClass.cxx:34
 TClass.cxx:35
 TClass.cxx:36
 TClass.cxx:37
 TClass.cxx:38
 TClass.cxx:39
 TClass.cxx:40
 TClass.cxx:41
 TClass.cxx:42
 TClass.cxx:43
 TClass.cxx:44
 TClass.cxx:45
 TClass.cxx:46
 TClass.cxx:47
 TClass.cxx:48
 TClass.cxx:49
 TClass.cxx:50
 TClass.cxx:51
 TClass.cxx:52
 TClass.cxx:53
 TClass.cxx:54
 TClass.cxx:55
 TClass.cxx:56
 TClass.cxx:57
 TClass.cxx:58
 TClass.cxx:59
 TClass.cxx:60
 TClass.cxx:61
 TClass.cxx:62
 TClass.cxx:63
 TClass.cxx:64
 TClass.cxx:65
 TClass.cxx:66
 TClass.cxx:67
 TClass.cxx:68
 TClass.cxx:69
 TClass.cxx:70
 TClass.cxx:71
 TClass.cxx:72
 TClass.cxx:73
 TClass.cxx:74
 TClass.cxx:75
 TClass.cxx:76
 TClass.cxx:77
 TClass.cxx:78
 TClass.cxx:79
 TClass.cxx:80
 TClass.cxx:81
 TClass.cxx:82
 TClass.cxx:83
 TClass.cxx:84
 TClass.cxx:85
 TClass.cxx:86
 TClass.cxx:87
 TClass.cxx:88
 TClass.cxx:89
 TClass.cxx:90
 TClass.cxx:91
 TClass.cxx:92
 TClass.cxx:93
 TClass.cxx:94
 TClass.cxx:95
 TClass.cxx:96
 TClass.cxx:97
 TClass.cxx:98
 TClass.cxx:99
 TClass.cxx:100
 TClass.cxx:101
 TClass.cxx:102
 TClass.cxx:103
 TClass.cxx:104
 TClass.cxx:105
 TClass.cxx:106
 TClass.cxx:107
 TClass.cxx:108
 TClass.cxx:109
 TClass.cxx:110
 TClass.cxx:111
 TClass.cxx:112
 TClass.cxx:113
 TClass.cxx:114
 TClass.cxx:115
 TClass.cxx:116
 TClass.cxx:117
 TClass.cxx:118
 TClass.cxx:119
 TClass.cxx:120
 TClass.cxx:121
 TClass.cxx:122
 TClass.cxx:123
 TClass.cxx:124
 TClass.cxx:125
 TClass.cxx:126
 TClass.cxx:127
 TClass.cxx:128
 TClass.cxx:129
 TClass.cxx:130
 TClass.cxx:131
 TClass.cxx:132
 TClass.cxx:133
 TClass.cxx:134
 TClass.cxx:135
 TClass.cxx:136
 TClass.cxx:137
 TClass.cxx:138
 TClass.cxx:139
 TClass.cxx:140
 TClass.cxx:141
 TClass.cxx:142
 TClass.cxx:143
 TClass.cxx:144
 TClass.cxx:145
 TClass.cxx:146
 TClass.cxx:147
 TClass.cxx:148
 TClass.cxx:149
 TClass.cxx:150
 TClass.cxx:151
 TClass.cxx:152
 TClass.cxx:153
 TClass.cxx:154
 TClass.cxx:155
 TClass.cxx:156
 TClass.cxx:157
 TClass.cxx:158
 TClass.cxx:159
 TClass.cxx:160
 TClass.cxx:161
 TClass.cxx:162
 TClass.cxx:163
 TClass.cxx:164
 TClass.cxx:165
 TClass.cxx:166
 TClass.cxx:167
 TClass.cxx:168
 TClass.cxx:169
 TClass.cxx:170
 TClass.cxx:171
 TClass.cxx:172
 TClass.cxx:173
 TClass.cxx:174
 TClass.cxx:175
 TClass.cxx:176
 TClass.cxx:177
 TClass.cxx:178
 TClass.cxx:179
 TClass.cxx:180
 TClass.cxx:181
 TClass.cxx:182
 TClass.cxx:183
 TClass.cxx:184
 TClass.cxx:185
 TClass.cxx:186
 TClass.cxx:187
 TClass.cxx:188
 TClass.cxx:189
 TClass.cxx:190
 TClass.cxx:191
 TClass.cxx:192
 TClass.cxx:193
 TClass.cxx:194
 TClass.cxx:195
 TClass.cxx:196
 TClass.cxx:197
 TClass.cxx:198
 TClass.cxx:199
 TClass.cxx:200
 TClass.cxx:201
 TClass.cxx:202
 TClass.cxx:203
 TClass.cxx:204
 TClass.cxx:205
 TClass.cxx:206
 TClass.cxx:207
 TClass.cxx:208
 TClass.cxx:209
 TClass.cxx:210
 TClass.cxx:211
 TClass.cxx:212
 TClass.cxx:213
 TClass.cxx:214
 TClass.cxx:215
 TClass.cxx:216
 TClass.cxx:217
 TClass.cxx:218
 TClass.cxx:219
 TClass.cxx:220
 TClass.cxx:221
 TClass.cxx:222
 TClass.cxx:223
 TClass.cxx:224
 TClass.cxx:225
 TClass.cxx:226
 TClass.cxx:227
 TClass.cxx:228
 TClass.cxx:229
 TClass.cxx:230
 TClass.cxx:231
 TClass.cxx:232
 TClass.cxx:233
 TClass.cxx:234
 TClass.cxx:235
 TClass.cxx:236
 TClass.cxx:237
 TClass.cxx:238
 TClass.cxx:239
 TClass.cxx:240
 TClass.cxx:241
 TClass.cxx:242
 TClass.cxx:243
 TClass.cxx:244
 TClass.cxx:245
 TClass.cxx:246
 TClass.cxx:247
 TClass.cxx:248
 TClass.cxx:249
 TClass.cxx:250
 TClass.cxx:251
 TClass.cxx:252
 TClass.cxx:253
 TClass.cxx:254
 TClass.cxx:255
 TClass.cxx:256
 TClass.cxx:257
 TClass.cxx:258
 TClass.cxx:259
 TClass.cxx:260
 TClass.cxx:261
 TClass.cxx:262
 TClass.cxx:263
 TClass.cxx:264
 TClass.cxx:265
 TClass.cxx:266
 TClass.cxx:267
 TClass.cxx:268
 TClass.cxx:269
 TClass.cxx:270
 TClass.cxx:271
 TClass.cxx:272
 TClass.cxx:273
 TClass.cxx:274
 TClass.cxx:275
 TClass.cxx:276
 TClass.cxx:277
 TClass.cxx:278
 TClass.cxx:279
 TClass.cxx:280
 TClass.cxx:281
 TClass.cxx:282
 TClass.cxx:283
 TClass.cxx:284
 TClass.cxx:285
 TClass.cxx:286
 TClass.cxx:287
 TClass.cxx:288
 TClass.cxx:289
 TClass.cxx:290
 TClass.cxx:291
 TClass.cxx:292
 TClass.cxx:293
 TClass.cxx:294
 TClass.cxx:295
 TClass.cxx:296
 TClass.cxx:297
 TClass.cxx:298
 TClass.cxx:299
 TClass.cxx:300
 TClass.cxx:301
 TClass.cxx:302
 TClass.cxx:303
 TClass.cxx:304
 TClass.cxx:305
 TClass.cxx:306
 TClass.cxx:307
 TClass.cxx:308
 TClass.cxx:309
 TClass.cxx:310
 TClass.cxx:311
 TClass.cxx:312
 TClass.cxx:313
 TClass.cxx:314
 TClass.cxx:315
 TClass.cxx:316
 TClass.cxx:317
 TClass.cxx:318
 TClass.cxx:319
 TClass.cxx:320
 TClass.cxx:321
 TClass.cxx:322
 TClass.cxx:323
 TClass.cxx:324
 TClass.cxx:325
 TClass.cxx:326
 TClass.cxx:327
 TClass.cxx:328
 TClass.cxx:329
 TClass.cxx:330
 TClass.cxx:331
 TClass.cxx:332
 TClass.cxx:333
 TClass.cxx:334
 TClass.cxx:335
 TClass.cxx:336
 TClass.cxx:337
 TClass.cxx:338
 TClass.cxx:339
 TClass.cxx:340
 TClass.cxx:341
 TClass.cxx:342
 TClass.cxx:343
 TClass.cxx:344
 TClass.cxx:345
 TClass.cxx:346
 TClass.cxx:347
 TClass.cxx:348
 TClass.cxx:349
 TClass.cxx:350
 TClass.cxx:351
 TClass.cxx:352
 TClass.cxx:353
 TClass.cxx:354
 TClass.cxx:355
 TClass.cxx:356
 TClass.cxx:357
 TClass.cxx:358
 TClass.cxx:359
 TClass.cxx:360
 TClass.cxx:361
 TClass.cxx:362
 TClass.cxx:363
 TClass.cxx:364
 TClass.cxx:365
 TClass.cxx:366
 TClass.cxx:367
 TClass.cxx:368
 TClass.cxx:369
 TClass.cxx:370
 TClass.cxx:371
 TClass.cxx:372
 TClass.cxx:373
 TClass.cxx:374
 TClass.cxx:375
 TClass.cxx:376
 TClass.cxx:377
 TClass.cxx:378
 TClass.cxx:379
 TClass.cxx:380
 TClass.cxx:381
 TClass.cxx:382
 TClass.cxx:383
 TClass.cxx:384
 TClass.cxx:385
 TClass.cxx:386
 TClass.cxx:387
 TClass.cxx:388
 TClass.cxx:389
 TClass.cxx:390
 TClass.cxx:391
 TClass.cxx:392
 TClass.cxx:393
 TClass.cxx:394
 TClass.cxx:395
 TClass.cxx:396
 TClass.cxx:397
 TClass.cxx:398
 TClass.cxx:399
 TClass.cxx:400
 TClass.cxx:401
 TClass.cxx:402
 TClass.cxx:403
 TClass.cxx:404
 TClass.cxx:405
 TClass.cxx:406
 TClass.cxx:407
 TClass.cxx:408
 TClass.cxx:409
 TClass.cxx:410
 TClass.cxx:411
 TClass.cxx:412
 TClass.cxx:413
 TClass.cxx:414
 TClass.cxx:415
 TClass.cxx:416
 TClass.cxx:417
 TClass.cxx:418
 TClass.cxx:419
 TClass.cxx:420
 TClass.cxx:421
 TClass.cxx:422
 TClass.cxx:423
 TClass.cxx:424
 TClass.cxx:425
 TClass.cxx:426
 TClass.cxx:427
 TClass.cxx:428
 TClass.cxx:429
 TClass.cxx:430
 TClass.cxx:431
 TClass.cxx:432
 TClass.cxx:433
 TClass.cxx:434
 TClass.cxx:435
 TClass.cxx:436
 TClass.cxx:437
 TClass.cxx:438
 TClass.cxx:439
 TClass.cxx:440
 TClass.cxx:441
 TClass.cxx:442
 TClass.cxx:443
 TClass.cxx:444
 TClass.cxx:445
 TClass.cxx:446
 TClass.cxx:447
 TClass.cxx:448
 TClass.cxx:449
 TClass.cxx:450
 TClass.cxx:451
 TClass.cxx:452
 TClass.cxx:453
 TClass.cxx:454
 TClass.cxx:455
 TClass.cxx:456
 TClass.cxx:457
 TClass.cxx:458
 TClass.cxx:459
 TClass.cxx:460
 TClass.cxx:461
 TClass.cxx:462
 TClass.cxx:463
 TClass.cxx:464
 TClass.cxx:465
 TClass.cxx:466
 TClass.cxx:467
 TClass.cxx:468
 TClass.cxx:469
 TClass.cxx:470
 TClass.cxx:471
 TClass.cxx:472
 TClass.cxx:473
 TClass.cxx:474
 TClass.cxx:475
 TClass.cxx:476
 TClass.cxx:477
 TClass.cxx:478
 TClass.cxx:479
 TClass.cxx:480
 TClass.cxx:481
 TClass.cxx:482
 TClass.cxx:483
 TClass.cxx:484
 TClass.cxx:485
 TClass.cxx:486
 TClass.cxx:487
 TClass.cxx:488
 TClass.cxx:489
 TClass.cxx:490
 TClass.cxx:491
 TClass.cxx:492
 TClass.cxx:493
 TClass.cxx:494
 TClass.cxx:495
 TClass.cxx:496
 TClass.cxx:497
 TClass.cxx:498
 TClass.cxx:499
 TClass.cxx:500
 TClass.cxx:501
 TClass.cxx:502
 TClass.cxx:503
 TClass.cxx:504
 TClass.cxx:505
 TClass.cxx:506
 TClass.cxx:507
 TClass.cxx:508
 TClass.cxx:509
 TClass.cxx:510
 TClass.cxx:511
 TClass.cxx:512
 TClass.cxx:513
 TClass.cxx:514
 TClass.cxx:515
 TClass.cxx:516
 TClass.cxx:517
 TClass.cxx:518
 TClass.cxx:519
 TClass.cxx:520
 TClass.cxx:521
 TClass.cxx:522
 TClass.cxx:523
 TClass.cxx:524
 TClass.cxx:525
 TClass.cxx:526
 TClass.cxx:527
 TClass.cxx:528
 TClass.cxx:529
 TClass.cxx:530
 TClass.cxx:531
 TClass.cxx:532
 TClass.cxx:533
 TClass.cxx:534
 TClass.cxx:535
 TClass.cxx:536
 TClass.cxx:537
 TClass.cxx:538
 TClass.cxx:539
 TClass.cxx:540
 TClass.cxx:541
 TClass.cxx:542
 TClass.cxx:543
 TClass.cxx:544
 TClass.cxx:545
 TClass.cxx:546
 TClass.cxx:547
 TClass.cxx:548
 TClass.cxx:549
 TClass.cxx:550
 TClass.cxx:551
 TClass.cxx:552
 TClass.cxx:553
 TClass.cxx:554
 TClass.cxx:555
 TClass.cxx:556
 TClass.cxx:557
 TClass.cxx:558
 TClass.cxx:559
 TClass.cxx:560
 TClass.cxx:561
 TClass.cxx:562
 TClass.cxx:563
 TClass.cxx:564
 TClass.cxx:565
 TClass.cxx:566
 TClass.cxx:567
 TClass.cxx:568
 TClass.cxx:569
 TClass.cxx:570
 TClass.cxx:571
 TClass.cxx:572
 TClass.cxx:573
 TClass.cxx:574
 TClass.cxx:575
 TClass.cxx:576
 TClass.cxx:577
 TClass.cxx:578
 TClass.cxx:579
 TClass.cxx:580
 TClass.cxx:581
 TClass.cxx:582
 TClass.cxx:583
 TClass.cxx:584
 TClass.cxx:585
 TClass.cxx:586
 TClass.cxx:587
 TClass.cxx:588
 TClass.cxx:589
 TClass.cxx:590
 TClass.cxx:591
 TClass.cxx:592
 TClass.cxx:593
 TClass.cxx:594
 TClass.cxx:595
 TClass.cxx:596
 TClass.cxx:597
 TClass.cxx:598
 TClass.cxx:599
 TClass.cxx:600
 TClass.cxx:601
 TClass.cxx:602
 TClass.cxx:603
 TClass.cxx:604
 TClass.cxx:605
 TClass.cxx:606
 TClass.cxx:607
 TClass.cxx:608
 TClass.cxx:609
 TClass.cxx:610
 TClass.cxx:611
 TClass.cxx:612
 TClass.cxx:613
 TClass.cxx:614
 TClass.cxx:615
 TClass.cxx:616
 TClass.cxx:617
 TClass.cxx:618
 TClass.cxx:619
 TClass.cxx:620
 TClass.cxx:621
 TClass.cxx:622
 TClass.cxx:623
 TClass.cxx:624
 TClass.cxx:625
 TClass.cxx:626
 TClass.cxx:627
 TClass.cxx:628
 TClass.cxx:629
 TClass.cxx:630
 TClass.cxx:631
 TClass.cxx:632
 TClass.cxx:633
 TClass.cxx:634
 TClass.cxx:635
 TClass.cxx:636
 TClass.cxx:637
 TClass.cxx:638
 TClass.cxx:639
 TClass.cxx:640
 TClass.cxx:641
 TClass.cxx:642
 TClass.cxx:643
 TClass.cxx:644
 TClass.cxx:645
 TClass.cxx:646
 TClass.cxx:647
 TClass.cxx:648
 TClass.cxx:649
 TClass.cxx:650
 TClass.cxx:651
 TClass.cxx:652
 TClass.cxx:653
 TClass.cxx:654
 TClass.cxx:655
 TClass.cxx:656
 TClass.cxx:657
 TClass.cxx:658
 TClass.cxx:659
 TClass.cxx:660
 TClass.cxx:661
 TClass.cxx:662
 TClass.cxx:663
 TClass.cxx:664
 TClass.cxx:665
 TClass.cxx:666
 TClass.cxx:667
 TClass.cxx:668
 TClass.cxx:669
 TClass.cxx:670
 TClass.cxx:671
 TClass.cxx:672
 TClass.cxx:673
 TClass.cxx:674
 TClass.cxx:675
 TClass.cxx:676
 TClass.cxx:677
 TClass.cxx:678
 TClass.cxx:679
 TClass.cxx:680
 TClass.cxx:681
 TClass.cxx:682
 TClass.cxx:683
 TClass.cxx:684
 TClass.cxx:685
 TClass.cxx:686
 TClass.cxx:687
 TClass.cxx:688
 TClass.cxx:689
 TClass.cxx:690
 TClass.cxx:691
 TClass.cxx:692
 TClass.cxx:693
 TClass.cxx:694
 TClass.cxx:695
 TClass.cxx:696
 TClass.cxx:697
 TClass.cxx:698
 TClass.cxx:699
 TClass.cxx:700
 TClass.cxx:701
 TClass.cxx:702
 TClass.cxx:703
 TClass.cxx:704
 TClass.cxx:705
 TClass.cxx:706
 TClass.cxx:707
 TClass.cxx:708
 TClass.cxx:709
 TClass.cxx:710
 TClass.cxx:711
 TClass.cxx:712
 TClass.cxx:713
 TClass.cxx:714
 TClass.cxx:715
 TClass.cxx:716
 TClass.cxx:717
 TClass.cxx:718
 TClass.cxx:719
 TClass.cxx:720
 TClass.cxx:721
 TClass.cxx:722
 TClass.cxx:723
 TClass.cxx:724
 TClass.cxx:725
 TClass.cxx:726
 TClass.cxx:727
 TClass.cxx:728
 TClass.cxx:729
 TClass.cxx:730
 TClass.cxx:731
 TClass.cxx:732
 TClass.cxx:733
 TClass.cxx:734
 TClass.cxx:735
 TClass.cxx:736
 TClass.cxx:737
 TClass.cxx:738
 TClass.cxx:739
 TClass.cxx:740
 TClass.cxx:741
 TClass.cxx:742
 TClass.cxx:743
 TClass.cxx:744
 TClass.cxx:745
 TClass.cxx:746
 TClass.cxx:747
 TClass.cxx:748
 TClass.cxx:749
 TClass.cxx:750
 TClass.cxx:751
 TClass.cxx:752
 TClass.cxx:753
 TClass.cxx:754
 TClass.cxx:755
 TClass.cxx:756
 TClass.cxx:757
 TClass.cxx:758
 TClass.cxx:759
 TClass.cxx:760
 TClass.cxx:761
 TClass.cxx:762
 TClass.cxx:763
 TClass.cxx:764
 TClass.cxx:765
 TClass.cxx:766
 TClass.cxx:767
 TClass.cxx:768
 TClass.cxx:769
 TClass.cxx:770
 TClass.cxx:771
 TClass.cxx:772
 TClass.cxx:773
 TClass.cxx:774
 TClass.cxx:775
 TClass.cxx:776
 TClass.cxx:777
 TClass.cxx:778
 TClass.cxx:779
 TClass.cxx:780
 TClass.cxx:781
 TClass.cxx:782
 TClass.cxx:783
 TClass.cxx:784
 TClass.cxx:785
 TClass.cxx:786
 TClass.cxx:787
 TClass.cxx:788
 TClass.cxx:789
 TClass.cxx:790
 TClass.cxx:791
 TClass.cxx:792
 TClass.cxx:793
 TClass.cxx:794
 TClass.cxx:795
 TClass.cxx:796
 TClass.cxx:797
 TClass.cxx:798
 TClass.cxx:799
 TClass.cxx:800
 TClass.cxx:801
 TClass.cxx:802
 TClass.cxx:803
 TClass.cxx:804
 TClass.cxx:805
 TClass.cxx:806
 TClass.cxx:807
 TClass.cxx:808
 TClass.cxx:809
 TClass.cxx:810
 TClass.cxx:811
 TClass.cxx:812
 TClass.cxx:813
 TClass.cxx:814
 TClass.cxx:815
 TClass.cxx:816
 TClass.cxx:817
 TClass.cxx:818
 TClass.cxx:819
 TClass.cxx:820
 TClass.cxx:821
 TClass.cxx:822
 TClass.cxx:823
 TClass.cxx:824
 TClass.cxx:825
 TClass.cxx:826
 TClass.cxx:827
 TClass.cxx:828
 TClass.cxx:829
 TClass.cxx:830
 TClass.cxx:831
 TClass.cxx:832
 TClass.cxx:833
 TClass.cxx:834
 TClass.cxx:835
 TClass.cxx:836
 TClass.cxx:837
 TClass.cxx:838
 TClass.cxx:839
 TClass.cxx:840
 TClass.cxx:841
 TClass.cxx:842
 TClass.cxx:843
 TClass.cxx:844
 TClass.cxx:845
 TClass.cxx:846
 TClass.cxx:847
 TClass.cxx:848
 TClass.cxx:849
 TClass.cxx:850
 TClass.cxx:851
 TClass.cxx:852
 TClass.cxx:853
 TClass.cxx:854
 TClass.cxx:855
 TClass.cxx:856
 TClass.cxx:857
 TClass.cxx:858
 TClass.cxx:859
 TClass.cxx:860
 TClass.cxx:861
 TClass.cxx:862
 TClass.cxx:863
 TClass.cxx:864
 TClass.cxx:865
 TClass.cxx:866
 TClass.cxx:867
 TClass.cxx:868
 TClass.cxx:869
 TClass.cxx:870
 TClass.cxx:871
 TClass.cxx:872
 TClass.cxx:873
 TClass.cxx:874
 TClass.cxx:875
 TClass.cxx:876
 TClass.cxx:877
 TClass.cxx:878
 TClass.cxx:879
 TClass.cxx:880
 TClass.cxx:881
 TClass.cxx:882
 TClass.cxx:883
 TClass.cxx:884
 TClass.cxx:885
 TClass.cxx:886
 TClass.cxx:887
 TClass.cxx:888
 TClass.cxx:889
 TClass.cxx:890
 TClass.cxx:891
 TClass.cxx:892
 TClass.cxx:893
 TClass.cxx:894
 TClass.cxx:895
 TClass.cxx:896
 TClass.cxx:897
 TClass.cxx:898
 TClass.cxx:899
 TClass.cxx:900
 TClass.cxx:901
 TClass.cxx:902
 TClass.cxx:903
 TClass.cxx:904
 TClass.cxx:905
 TClass.cxx:906
 TClass.cxx:907
 TClass.cxx:908
 TClass.cxx:909
 TClass.cxx:910
 TClass.cxx:911
 TClass.cxx:912
 TClass.cxx:913
 TClass.cxx:914
 TClass.cxx:915
 TClass.cxx:916
 TClass.cxx:917
 TClass.cxx:918
 TClass.cxx:919
 TClass.cxx:920
 TClass.cxx:921
 TClass.cxx:922
 TClass.cxx:923
 TClass.cxx:924
 TClass.cxx:925
 TClass.cxx:926
 TClass.cxx:927
 TClass.cxx:928
 TClass.cxx:929
 TClass.cxx:930
 TClass.cxx:931
 TClass.cxx:932
 TClass.cxx:933
 TClass.cxx:934
 TClass.cxx:935
 TClass.cxx:936
 TClass.cxx:937
 TClass.cxx:938
 TClass.cxx:939
 TClass.cxx:940
 TClass.cxx:941
 TClass.cxx:942
 TClass.cxx:943
 TClass.cxx:944
 TClass.cxx:945
 TClass.cxx:946
 TClass.cxx:947
 TClass.cxx:948
 TClass.cxx:949
 TClass.cxx:950
 TClass.cxx:951
 TClass.cxx:952
 TClass.cxx:953
 TClass.cxx:954
 TClass.cxx:955
 TClass.cxx:956
 TClass.cxx:957
 TClass.cxx:958
 TClass.cxx:959
 TClass.cxx:960
 TClass.cxx:961
 TClass.cxx:962
 TClass.cxx:963
 TClass.cxx:964
 TClass.cxx:965
 TClass.cxx:966
 TClass.cxx:967
 TClass.cxx:968
 TClass.cxx:969
 TClass.cxx:970
 TClass.cxx:971
 TClass.cxx:972
 TClass.cxx:973
 TClass.cxx:974
 TClass.cxx:975
 TClass.cxx:976
 TClass.cxx:977
 TClass.cxx:978
 TClass.cxx:979
 TClass.cxx:980
 TClass.cxx:981
 TClass.cxx:982
 TClass.cxx:983
 TClass.cxx:984
 TClass.cxx:985
 TClass.cxx:986
 TClass.cxx:987
 TClass.cxx:988
 TClass.cxx:989
 TClass.cxx:990
 TClass.cxx:991
 TClass.cxx:992
 TClass.cxx:993
 TClass.cxx:994
 TClass.cxx:995
 TClass.cxx:996
 TClass.cxx:997
 TClass.cxx:998
 TClass.cxx:999
 TClass.cxx:1000
 TClass.cxx:1001
 TClass.cxx:1002
 TClass.cxx:1003
 TClass.cxx:1004
 TClass.cxx:1005
 TClass.cxx:1006
 TClass.cxx:1007
 TClass.cxx:1008
 TClass.cxx:1009
 TClass.cxx:1010
 TClass.cxx:1011
 TClass.cxx:1012
 TClass.cxx:1013
 TClass.cxx:1014
 TClass.cxx:1015
 TClass.cxx:1016
 TClass.cxx:1017
 TClass.cxx:1018
 TClass.cxx:1019
 TClass.cxx:1020
 TClass.cxx:1021
 TClass.cxx:1022
 TClass.cxx:1023
 TClass.cxx:1024
 TClass.cxx:1025
 TClass.cxx:1026
 TClass.cxx:1027
 TClass.cxx:1028
 TClass.cxx:1029
 TClass.cxx:1030
 TClass.cxx:1031
 TClass.cxx:1032
 TClass.cxx:1033
 TClass.cxx:1034
 TClass.cxx:1035
 TClass.cxx:1036
 TClass.cxx:1037
 TClass.cxx:1038
 TClass.cxx:1039
 TClass.cxx:1040
 TClass.cxx:1041
 TClass.cxx:1042
 TClass.cxx:1043
 TClass.cxx:1044
 TClass.cxx:1045
 TClass.cxx:1046
 TClass.cxx:1047
 TClass.cxx:1048
 TClass.cxx:1049
 TClass.cxx:1050
 TClass.cxx:1051
 TClass.cxx:1052
 TClass.cxx:1053
 TClass.cxx:1054
 TClass.cxx:1055
 TClass.cxx:1056
 TClass.cxx:1057
 TClass.cxx:1058
 TClass.cxx:1059
 TClass.cxx:1060
 TClass.cxx:1061
 TClass.cxx:1062
 TClass.cxx:1063
 TClass.cxx:1064
 TClass.cxx:1065
 TClass.cxx:1066
 TClass.cxx:1067
 TClass.cxx:1068
 TClass.cxx:1069
 TClass.cxx:1070
 TClass.cxx:1071
 TClass.cxx:1072
 TClass.cxx:1073
 TClass.cxx:1074
 TClass.cxx:1075
 TClass.cxx:1076
 TClass.cxx:1077
 TClass.cxx:1078
 TClass.cxx:1079
 TClass.cxx:1080
 TClass.cxx:1081
 TClass.cxx:1082
 TClass.cxx:1083
 TClass.cxx:1084
 TClass.cxx:1085
 TClass.cxx:1086
 TClass.cxx:1087
 TClass.cxx:1088
 TClass.cxx:1089
 TClass.cxx:1090
 TClass.cxx:1091
 TClass.cxx:1092
 TClass.cxx:1093
 TClass.cxx:1094
 TClass.cxx:1095
 TClass.cxx:1096
 TClass.cxx:1097
 TClass.cxx:1098
 TClass.cxx:1099
 TClass.cxx:1100
 TClass.cxx:1101
 TClass.cxx:1102
 TClass.cxx:1103
 TClass.cxx:1104
 TClass.cxx:1105
 TClass.cxx:1106
 TClass.cxx:1107
 TClass.cxx:1108
 TClass.cxx:1109
 TClass.cxx:1110
 TClass.cxx:1111
 TClass.cxx:1112
 TClass.cxx:1113
 TClass.cxx:1114
 TClass.cxx:1115
 TClass.cxx:1116
 TClass.cxx:1117
 TClass.cxx:1118
 TClass.cxx:1119
 TClass.cxx:1120
 TClass.cxx:1121
 TClass.cxx:1122
 TClass.cxx:1123
 TClass.cxx:1124
 TClass.cxx:1125
 TClass.cxx:1126
 TClass.cxx:1127
 TClass.cxx:1128
 TClass.cxx:1129
 TClass.cxx:1130
 TClass.cxx:1131
 TClass.cxx:1132
 TClass.cxx:1133
 TClass.cxx:1134
 TClass.cxx:1135
 TClass.cxx:1136
 TClass.cxx:1137
 TClass.cxx:1138
 TClass.cxx:1139
 TClass.cxx:1140
 TClass.cxx:1141
 TClass.cxx:1142
 TClass.cxx:1143
 TClass.cxx:1144
 TClass.cxx:1145
 TClass.cxx:1146
 TClass.cxx:1147
 TClass.cxx:1148
 TClass.cxx:1149
 TClass.cxx:1150
 TClass.cxx:1151
 TClass.cxx:1152
 TClass.cxx:1153
 TClass.cxx:1154
 TClass.cxx:1155
 TClass.cxx:1156
 TClass.cxx:1157
 TClass.cxx:1158
 TClass.cxx:1159
 TClass.cxx:1160
 TClass.cxx:1161
 TClass.cxx:1162
 TClass.cxx:1163
 TClass.cxx:1164
 TClass.cxx:1165
 TClass.cxx:1166
 TClass.cxx:1167
 TClass.cxx:1168
 TClass.cxx:1169
 TClass.cxx:1170
 TClass.cxx:1171
 TClass.cxx:1172
 TClass.cxx:1173
 TClass.cxx:1174
 TClass.cxx:1175
 TClass.cxx:1176
 TClass.cxx:1177
 TClass.cxx:1178
 TClass.cxx:1179
 TClass.cxx:1180
 TClass.cxx:1181
 TClass.cxx:1182
 TClass.cxx:1183
 TClass.cxx:1184
 TClass.cxx:1185
 TClass.cxx:1186
 TClass.cxx:1187
 TClass.cxx:1188
 TClass.cxx:1189
 TClass.cxx:1190
 TClass.cxx:1191
 TClass.cxx:1192
 TClass.cxx:1193
 TClass.cxx:1194
 TClass.cxx:1195
 TClass.cxx:1196
 TClass.cxx:1197
 TClass.cxx:1198
 TClass.cxx:1199
 TClass.cxx:1200
 TClass.cxx:1201
 TClass.cxx:1202
 TClass.cxx:1203
 TClass.cxx:1204
 TClass.cxx:1205
 TClass.cxx:1206
 TClass.cxx:1207
 TClass.cxx:1208
 TClass.cxx:1209
 TClass.cxx:1210
 TClass.cxx:1211
 TClass.cxx:1212
 TClass.cxx:1213
 TClass.cxx:1214
 TClass.cxx:1215
 TClass.cxx:1216
 TClass.cxx:1217
 TClass.cxx:1218
 TClass.cxx:1219
 TClass.cxx:1220
 TClass.cxx:1221
 TClass.cxx:1222
 TClass.cxx:1223
 TClass.cxx:1224
 TClass.cxx:1225
 TClass.cxx:1226
 TClass.cxx:1227
 TClass.cxx:1228
 TClass.cxx:1229
 TClass.cxx:1230
 TClass.cxx:1231
 TClass.cxx:1232
 TClass.cxx:1233
 TClass.cxx:1234
 TClass.cxx:1235
 TClass.cxx:1236
 TClass.cxx:1237
 TClass.cxx:1238
 TClass.cxx:1239
 TClass.cxx:1240
 TClass.cxx:1241
 TClass.cxx:1242
 TClass.cxx:1243
 TClass.cxx:1244
 TClass.cxx:1245
 TClass.cxx:1246
 TClass.cxx:1247
 TClass.cxx:1248
 TClass.cxx:1249
 TClass.cxx:1250
 TClass.cxx:1251
 TClass.cxx:1252
 TClass.cxx:1253
 TClass.cxx:1254
 TClass.cxx:1255
 TClass.cxx:1256
 TClass.cxx:1257
 TClass.cxx:1258
 TClass.cxx:1259
 TClass.cxx:1260
 TClass.cxx:1261
 TClass.cxx:1262
 TClass.cxx:1263
 TClass.cxx:1264
 TClass.cxx:1265
 TClass.cxx:1266
 TClass.cxx:1267
 TClass.cxx:1268
 TClass.cxx:1269
 TClass.cxx:1270
 TClass.cxx:1271
 TClass.cxx:1272
 TClass.cxx:1273
 TClass.cxx:1274
 TClass.cxx:1275
 TClass.cxx:1276
 TClass.cxx:1277
 TClass.cxx:1278
 TClass.cxx:1279
 TClass.cxx:1280
 TClass.cxx:1281
 TClass.cxx:1282
 TClass.cxx:1283
 TClass.cxx:1284
 TClass.cxx:1285
 TClass.cxx:1286
 TClass.cxx:1287
 TClass.cxx:1288
 TClass.cxx:1289
 TClass.cxx:1290
 TClass.cxx:1291
 TClass.cxx:1292
 TClass.cxx:1293
 TClass.cxx:1294
 TClass.cxx:1295
 TClass.cxx:1296
 TClass.cxx:1297
 TClass.cxx:1298
 TClass.cxx:1299
 TClass.cxx:1300
 TClass.cxx:1301
 TClass.cxx:1302
 TClass.cxx:1303
 TClass.cxx:1304
 TClass.cxx:1305
 TClass.cxx:1306
 TClass.cxx:1307
 TClass.cxx:1308
 TClass.cxx:1309
 TClass.cxx:1310
 TClass.cxx:1311
 TClass.cxx:1312
 TClass.cxx:1313
 TClass.cxx:1314
 TClass.cxx:1315
 TClass.cxx:1316
 TClass.cxx:1317
 TClass.cxx:1318
 TClass.cxx:1319
 TClass.cxx:1320
 TClass.cxx:1321
 TClass.cxx:1322
 TClass.cxx:1323
 TClass.cxx:1324
 TClass.cxx:1325
 TClass.cxx:1326
 TClass.cxx:1327
 TClass.cxx:1328
 TClass.cxx:1329
 TClass.cxx:1330
 TClass.cxx:1331
 TClass.cxx:1332
 TClass.cxx:1333
 TClass.cxx:1334
 TClass.cxx:1335
 TClass.cxx:1336
 TClass.cxx:1337
 TClass.cxx:1338
 TClass.cxx:1339
 TClass.cxx:1340
 TClass.cxx:1341
 TClass.cxx:1342
 TClass.cxx:1343
 TClass.cxx:1344
 TClass.cxx:1345
 TClass.cxx:1346
 TClass.cxx:1347
 TClass.cxx:1348
 TClass.cxx:1349
 TClass.cxx:1350
 TClass.cxx:1351
 TClass.cxx:1352
 TClass.cxx:1353
 TClass.cxx:1354
 TClass.cxx:1355
 TClass.cxx:1356
 TClass.cxx:1357
 TClass.cxx:1358
 TClass.cxx:1359
 TClass.cxx:1360
 TClass.cxx:1361
 TClass.cxx:1362
 TClass.cxx:1363
 TClass.cxx:1364
 TClass.cxx:1365
 TClass.cxx:1366
 TClass.cxx:1367
 TClass.cxx:1368
 TClass.cxx:1369
 TClass.cxx:1370
 TClass.cxx:1371
 TClass.cxx:1372
 TClass.cxx:1373
 TClass.cxx:1374
 TClass.cxx:1375
 TClass.cxx:1376
 TClass.cxx:1377
 TClass.cxx:1378
 TClass.cxx:1379
 TClass.cxx:1380
 TClass.cxx:1381
 TClass.cxx:1382
 TClass.cxx:1383
 TClass.cxx:1384
 TClass.cxx:1385
 TClass.cxx:1386
 TClass.cxx:1387
 TClass.cxx:1388
 TClass.cxx:1389
 TClass.cxx:1390
 TClass.cxx:1391
 TClass.cxx:1392
 TClass.cxx:1393
 TClass.cxx:1394
 TClass.cxx:1395
 TClass.cxx:1396
 TClass.cxx:1397
 TClass.cxx:1398
 TClass.cxx:1399
 TClass.cxx:1400
 TClass.cxx:1401
 TClass.cxx:1402
 TClass.cxx:1403
 TClass.cxx:1404
 TClass.cxx:1405
 TClass.cxx:1406
 TClass.cxx:1407
 TClass.cxx:1408
 TClass.cxx:1409
 TClass.cxx:1410
 TClass.cxx:1411
 TClass.cxx:1412
 TClass.cxx:1413
 TClass.cxx:1414
 TClass.cxx:1415
 TClass.cxx:1416
 TClass.cxx:1417
 TClass.cxx:1418
 TClass.cxx:1419
 TClass.cxx:1420
 TClass.cxx:1421
 TClass.cxx:1422
 TClass.cxx:1423
 TClass.cxx:1424
 TClass.cxx:1425
 TClass.cxx:1426
 TClass.cxx:1427
 TClass.cxx:1428
 TClass.cxx:1429
 TClass.cxx:1430
 TClass.cxx:1431
 TClass.cxx:1432
 TClass.cxx:1433
 TClass.cxx:1434
 TClass.cxx:1435
 TClass.cxx:1436
 TClass.cxx:1437
 TClass.cxx:1438
 TClass.cxx:1439
 TClass.cxx:1440
 TClass.cxx:1441
 TClass.cxx:1442
 TClass.cxx:1443
 TClass.cxx:1444
 TClass.cxx:1445
 TClass.cxx:1446
 TClass.cxx:1447
 TClass.cxx:1448
 TClass.cxx:1449
 TClass.cxx:1450
 TClass.cxx:1451
 TClass.cxx:1452
 TClass.cxx:1453
 TClass.cxx:1454
 TClass.cxx:1455
 TClass.cxx:1456
 TClass.cxx:1457
 TClass.cxx:1458
 TClass.cxx:1459
 TClass.cxx:1460
 TClass.cxx:1461
 TClass.cxx:1462
 TClass.cxx:1463
 TClass.cxx:1464
 TClass.cxx:1465
 TClass.cxx:1466
 TClass.cxx:1467
 TClass.cxx:1468
 TClass.cxx:1469
 TClass.cxx:1470
 TClass.cxx:1471
 TClass.cxx:1472
 TClass.cxx:1473
 TClass.cxx:1474
 TClass.cxx:1475
 TClass.cxx:1476
 TClass.cxx:1477
 TClass.cxx:1478
 TClass.cxx:1479
 TClass.cxx:1480
 TClass.cxx:1481
 TClass.cxx:1482
 TClass.cxx:1483
 TClass.cxx:1484
 TClass.cxx:1485
 TClass.cxx:1486
 TClass.cxx:1487
 TClass.cxx:1488
 TClass.cxx:1489
 TClass.cxx:1490
 TClass.cxx:1491
 TClass.cxx:1492
 TClass.cxx:1493
 TClass.cxx:1494
 TClass.cxx:1495
 TClass.cxx:1496
 TClass.cxx:1497
 TClass.cxx:1498
 TClass.cxx:1499
 TClass.cxx:1500
 TClass.cxx:1501
 TClass.cxx:1502
 TClass.cxx:1503
 TClass.cxx:1504
 TClass.cxx:1505
 TClass.cxx:1506
 TClass.cxx:1507
 TClass.cxx:1508
 TClass.cxx:1509
 TClass.cxx:1510
 TClass.cxx:1511
 TClass.cxx:1512
 TClass.cxx:1513
 TClass.cxx:1514
 TClass.cxx:1515
 TClass.cxx:1516
 TClass.cxx:1517
 TClass.cxx:1518
 TClass.cxx:1519
 TClass.cxx:1520
 TClass.cxx:1521
 TClass.cxx:1522
 TClass.cxx:1523
 TClass.cxx:1524
 TClass.cxx:1525
 TClass.cxx:1526
 TClass.cxx:1527
 TClass.cxx:1528
 TClass.cxx:1529
 TClass.cxx:1530
 TClass.cxx:1531
 TClass.cxx:1532
 TClass.cxx:1533
 TClass.cxx:1534
 TClass.cxx:1535
 TClass.cxx:1536
 TClass.cxx:1537
 TClass.cxx:1538
 TClass.cxx:1539
 TClass.cxx:1540
 TClass.cxx:1541
 TClass.cxx:1542
 TClass.cxx:1543
 TClass.cxx:1544
 TClass.cxx:1545
 TClass.cxx:1546
 TClass.cxx:1547
 TClass.cxx:1548
 TClass.cxx:1549
 TClass.cxx:1550
 TClass.cxx:1551
 TClass.cxx:1552
 TClass.cxx:1553
 TClass.cxx:1554
 TClass.cxx:1555
 TClass.cxx:1556
 TClass.cxx:1557
 TClass.cxx:1558
 TClass.cxx:1559
 TClass.cxx:1560
 TClass.cxx:1561
 TClass.cxx:1562
 TClass.cxx:1563
 TClass.cxx:1564
 TClass.cxx:1565
 TClass.cxx:1566
 TClass.cxx:1567
 TClass.cxx:1568
 TClass.cxx:1569
 TClass.cxx:1570
 TClass.cxx:1571
 TClass.cxx:1572
 TClass.cxx:1573
 TClass.cxx:1574
 TClass.cxx:1575
 TClass.cxx:1576
 TClass.cxx:1577
 TClass.cxx:1578
 TClass.cxx:1579
 TClass.cxx:1580
 TClass.cxx:1581
 TClass.cxx:1582
 TClass.cxx:1583
 TClass.cxx:1584
 TClass.cxx:1585
 TClass.cxx:1586
 TClass.cxx:1587
 TClass.cxx:1588
 TClass.cxx:1589
 TClass.cxx:1590
 TClass.cxx:1591
 TClass.cxx:1592
 TClass.cxx:1593
 TClass.cxx:1594
 TClass.cxx:1595
 TClass.cxx:1596
 TClass.cxx:1597
 TClass.cxx:1598
 TClass.cxx:1599
 TClass.cxx:1600
 TClass.cxx:1601
 TClass.cxx:1602
 TClass.cxx:1603
 TClass.cxx:1604
 TClass.cxx:1605
 TClass.cxx:1606
 TClass.cxx:1607
 TClass.cxx:1608
 TClass.cxx:1609
 TClass.cxx:1610
 TClass.cxx:1611
 TClass.cxx:1612
 TClass.cxx:1613
 TClass.cxx:1614
 TClass.cxx:1615
 TClass.cxx:1616
 TClass.cxx:1617
 TClass.cxx:1618
 TClass.cxx:1619
 TClass.cxx:1620
 TClass.cxx:1621
 TClass.cxx:1622
 TClass.cxx:1623
 TClass.cxx:1624
 TClass.cxx:1625
 TClass.cxx:1626
 TClass.cxx:1627
 TClass.cxx:1628
 TClass.cxx:1629
 TClass.cxx:1630
 TClass.cxx:1631
 TClass.cxx:1632
 TClass.cxx:1633
 TClass.cxx:1634
 TClass.cxx:1635
 TClass.cxx:1636
 TClass.cxx:1637
 TClass.cxx:1638
 TClass.cxx:1639
 TClass.cxx:1640
 TClass.cxx:1641
 TClass.cxx:1642
 TClass.cxx:1643
 TClass.cxx:1644
 TClass.cxx:1645
 TClass.cxx:1646
 TClass.cxx:1647
 TClass.cxx:1648
 TClass.cxx:1649
 TClass.cxx:1650
 TClass.cxx:1651
 TClass.cxx:1652
 TClass.cxx:1653
 TClass.cxx:1654
 TClass.cxx:1655
 TClass.cxx:1656
 TClass.cxx:1657
 TClass.cxx:1658
 TClass.cxx:1659
 TClass.cxx:1660
 TClass.cxx:1661
 TClass.cxx:1662
 TClass.cxx:1663
 TClass.cxx:1664
 TClass.cxx:1665
 TClass.cxx:1666
 TClass.cxx:1667
 TClass.cxx:1668
 TClass.cxx:1669
 TClass.cxx:1670
 TClass.cxx:1671
 TClass.cxx:1672
 TClass.cxx:1673
 TClass.cxx:1674
 TClass.cxx:1675
 TClass.cxx:1676
 TClass.cxx:1677
 TClass.cxx:1678
 TClass.cxx:1679
 TClass.cxx:1680
 TClass.cxx:1681
 TClass.cxx:1682
 TClass.cxx:1683
 TClass.cxx:1684
 TClass.cxx:1685
 TClass.cxx:1686
 TClass.cxx:1687
 TClass.cxx:1688
 TClass.cxx:1689
 TClass.cxx:1690
 TClass.cxx:1691
 TClass.cxx:1692
 TClass.cxx:1693
 TClass.cxx:1694
 TClass.cxx:1695
 TClass.cxx:1696
 TClass.cxx:1697
 TClass.cxx:1698
 TClass.cxx:1699
 TClass.cxx:1700
 TClass.cxx:1701
 TClass.cxx:1702
 TClass.cxx:1703
 TClass.cxx:1704
 TClass.cxx:1705
 TClass.cxx:1706
 TClass.cxx:1707
 TClass.cxx:1708
 TClass.cxx:1709
 TClass.cxx:1710
 TClass.cxx:1711
 TClass.cxx:1712
 TClass.cxx:1713
 TClass.cxx:1714
 TClass.cxx:1715
 TClass.cxx:1716
 TClass.cxx:1717
 TClass.cxx:1718
 TClass.cxx:1719
 TClass.cxx:1720
 TClass.cxx:1721
 TClass.cxx:1722
 TClass.cxx:1723
 TClass.cxx:1724
 TClass.cxx:1725
 TClass.cxx:1726
 TClass.cxx:1727
 TClass.cxx:1728
 TClass.cxx:1729
 TClass.cxx:1730
 TClass.cxx:1731
 TClass.cxx:1732
 TClass.cxx:1733
 TClass.cxx:1734
 TClass.cxx:1735
 TClass.cxx:1736
 TClass.cxx:1737
 TClass.cxx:1738
 TClass.cxx:1739
 TClass.cxx:1740
 TClass.cxx:1741
 TClass.cxx:1742
 TClass.cxx:1743
 TClass.cxx:1744
 TClass.cxx:1745
 TClass.cxx:1746
 TClass.cxx:1747
 TClass.cxx:1748
 TClass.cxx:1749
 TClass.cxx:1750
 TClass.cxx:1751
 TClass.cxx:1752
 TClass.cxx:1753
 TClass.cxx:1754
 TClass.cxx:1755
 TClass.cxx:1756
 TClass.cxx:1757
 TClass.cxx:1758
 TClass.cxx:1759
 TClass.cxx:1760
 TClass.cxx:1761
 TClass.cxx:1762
 TClass.cxx:1763
 TClass.cxx:1764
 TClass.cxx:1765
 TClass.cxx:1766
 TClass.cxx:1767
 TClass.cxx:1768
 TClass.cxx:1769
 TClass.cxx:1770
 TClass.cxx:1771
 TClass.cxx:1772
 TClass.cxx:1773
 TClass.cxx:1774
 TClass.cxx:1775
 TClass.cxx:1776
 TClass.cxx:1777
 TClass.cxx:1778
 TClass.cxx:1779
 TClass.cxx:1780
 TClass.cxx:1781
 TClass.cxx:1782
 TClass.cxx:1783
 TClass.cxx:1784
 TClass.cxx:1785
 TClass.cxx:1786
 TClass.cxx:1787
 TClass.cxx:1788
 TClass.cxx:1789
 TClass.cxx:1790
 TClass.cxx:1791
 TClass.cxx:1792
 TClass.cxx:1793
 TClass.cxx:1794
 TClass.cxx:1795
 TClass.cxx:1796
 TClass.cxx:1797
 TClass.cxx:1798
 TClass.cxx:1799
 TClass.cxx:1800
 TClass.cxx:1801
 TClass.cxx:1802
 TClass.cxx:1803
 TClass.cxx:1804
 TClass.cxx:1805
 TClass.cxx:1806
 TClass.cxx:1807
 TClass.cxx:1808
 TClass.cxx:1809
 TClass.cxx:1810
 TClass.cxx:1811
 TClass.cxx:1812
 TClass.cxx:1813
 TClass.cxx:1814
 TClass.cxx:1815
 TClass.cxx:1816
 TClass.cxx:1817
 TClass.cxx:1818
 TClass.cxx:1819
 TClass.cxx:1820
 TClass.cxx:1821
 TClass.cxx:1822
 TClass.cxx:1823
 TClass.cxx:1824
 TClass.cxx:1825
 TClass.cxx:1826
 TClass.cxx:1827
 TClass.cxx:1828
 TClass.cxx:1829
 TClass.cxx:1830
 TClass.cxx:1831
 TClass.cxx:1832
 TClass.cxx:1833
 TClass.cxx:1834
 TClass.cxx:1835
 TClass.cxx:1836
 TClass.cxx:1837
 TClass.cxx:1838
 TClass.cxx:1839
 TClass.cxx:1840
 TClass.cxx:1841
 TClass.cxx:1842
 TClass.cxx:1843
 TClass.cxx:1844
 TClass.cxx:1845
 TClass.cxx:1846
 TClass.cxx:1847
 TClass.cxx:1848
 TClass.cxx:1849
 TClass.cxx:1850
 TClass.cxx:1851
 TClass.cxx:1852
 TClass.cxx:1853
 TClass.cxx:1854
 TClass.cxx:1855
 TClass.cxx:1856
 TClass.cxx:1857
 TClass.cxx:1858
 TClass.cxx:1859
 TClass.cxx:1860
 TClass.cxx:1861
 TClass.cxx:1862
 TClass.cxx:1863
 TClass.cxx:1864
 TClass.cxx:1865
 TClass.cxx:1866
 TClass.cxx:1867
 TClass.cxx:1868
 TClass.cxx:1869
 TClass.cxx:1870
 TClass.cxx:1871
 TClass.cxx:1872
 TClass.cxx:1873
 TClass.cxx:1874
 TClass.cxx:1875
 TClass.cxx:1876
 TClass.cxx:1877
 TClass.cxx:1878
 TClass.cxx:1879
 TClass.cxx:1880
 TClass.cxx:1881
 TClass.cxx:1882
 TClass.cxx:1883
 TClass.cxx:1884
 TClass.cxx:1885
 TClass.cxx:1886
 TClass.cxx:1887
 TClass.cxx:1888
 TClass.cxx:1889
 TClass.cxx:1890
 TClass.cxx:1891
 TClass.cxx:1892
 TClass.cxx:1893
 TClass.cxx:1894
 TClass.cxx:1895
 TClass.cxx:1896
 TClass.cxx:1897
 TClass.cxx:1898
 TClass.cxx:1899
 TClass.cxx:1900
 TClass.cxx:1901
 TClass.cxx:1902
 TClass.cxx:1903
 TClass.cxx:1904
 TClass.cxx:1905
 TClass.cxx:1906
 TClass.cxx:1907
 TClass.cxx:1908
 TClass.cxx:1909
 TClass.cxx:1910
 TClass.cxx:1911
 TClass.cxx:1912
 TClass.cxx:1913
 TClass.cxx:1914
 TClass.cxx:1915
 TClass.cxx:1916
 TClass.cxx:1917
 TClass.cxx:1918
 TClass.cxx:1919
 TClass.cxx:1920
 TClass.cxx:1921
 TClass.cxx:1922
 TClass.cxx:1923
 TClass.cxx:1924
 TClass.cxx:1925
 TClass.cxx:1926
 TClass.cxx:1927
 TClass.cxx:1928
 TClass.cxx:1929
 TClass.cxx:1930
 TClass.cxx:1931
 TClass.cxx:1932
 TClass.cxx:1933
 TClass.cxx:1934
 TClass.cxx:1935
 TClass.cxx:1936
 TClass.cxx:1937
 TClass.cxx:1938
 TClass.cxx:1939
 TClass.cxx:1940
 TClass.cxx:1941
 TClass.cxx:1942
 TClass.cxx:1943
 TClass.cxx:1944
 TClass.cxx:1945
 TClass.cxx:1946
 TClass.cxx:1947
 TClass.cxx:1948
 TClass.cxx:1949
 TClass.cxx:1950
 TClass.cxx:1951
 TClass.cxx:1952
 TClass.cxx:1953
 TClass.cxx:1954
 TClass.cxx:1955
 TClass.cxx:1956
 TClass.cxx:1957
 TClass.cxx:1958
 TClass.cxx:1959
 TClass.cxx:1960
 TClass.cxx:1961
 TClass.cxx:1962
 TClass.cxx:1963
 TClass.cxx:1964
 TClass.cxx:1965
 TClass.cxx:1966
 TClass.cxx:1967
 TClass.cxx:1968
 TClass.cxx:1969
 TClass.cxx:1970
 TClass.cxx:1971
 TClass.cxx:1972
 TClass.cxx:1973
 TClass.cxx:1974
 TClass.cxx:1975
 TClass.cxx:1976
 TClass.cxx:1977
 TClass.cxx:1978
 TClass.cxx:1979
 TClass.cxx:1980
 TClass.cxx:1981
 TClass.cxx:1982
 TClass.cxx:1983
 TClass.cxx:1984
 TClass.cxx:1985
 TClass.cxx:1986
 TClass.cxx:1987
 TClass.cxx:1988
 TClass.cxx:1989
 TClass.cxx:1990
 TClass.cxx:1991
 TClass.cxx:1992
 TClass.cxx:1993
 TClass.cxx:1994
 TClass.cxx:1995
 TClass.cxx:1996
 TClass.cxx:1997
 TClass.cxx:1998
 TClass.cxx:1999
 TClass.cxx:2000
 TClass.cxx:2001
 TClass.cxx:2002
 TClass.cxx:2003
 TClass.cxx:2004
 TClass.cxx:2005
 TClass.cxx:2006
 TClass.cxx:2007
 TClass.cxx:2008
 TClass.cxx:2009
 TClass.cxx:2010
 TClass.cxx:2011
 TClass.cxx:2012
 TClass.cxx:2013
 TClass.cxx:2014
 TClass.cxx:2015
 TClass.cxx:2016
 TClass.cxx:2017
 TClass.cxx:2018
 TClass.cxx:2019
 TClass.cxx:2020
 TClass.cxx:2021
 TClass.cxx:2022
 TClass.cxx:2023
 TClass.cxx:2024
 TClass.cxx:2025
 TClass.cxx:2026
 TClass.cxx:2027
 TClass.cxx:2028
 TClass.cxx:2029
 TClass.cxx:2030
 TClass.cxx:2031
 TClass.cxx:2032
 TClass.cxx:2033
 TClass.cxx:2034
 TClass.cxx:2035
 TClass.cxx:2036
 TClass.cxx:2037
 TClass.cxx:2038
 TClass.cxx:2039
 TClass.cxx:2040
 TClass.cxx:2041
 TClass.cxx:2042
 TClass.cxx:2043
 TClass.cxx:2044
 TClass.cxx:2045
 TClass.cxx:2046
 TClass.cxx:2047
 TClass.cxx:2048
 TClass.cxx:2049
 TClass.cxx:2050
 TClass.cxx:2051
 TClass.cxx:2052
 TClass.cxx:2053
 TClass.cxx:2054
 TClass.cxx:2055
 TClass.cxx:2056
 TClass.cxx:2057
 TClass.cxx:2058
 TClass.cxx:2059
 TClass.cxx:2060
 TClass.cxx:2061
 TClass.cxx:2062
 TClass.cxx:2063
 TClass.cxx:2064
 TClass.cxx:2065
 TClass.cxx:2066
 TClass.cxx:2067
 TClass.cxx:2068
 TClass.cxx:2069
 TClass.cxx:2070
 TClass.cxx:2071
 TClass.cxx:2072
 TClass.cxx:2073
 TClass.cxx:2074
 TClass.cxx:2075
 TClass.cxx:2076
 TClass.cxx:2077
 TClass.cxx:2078
 TClass.cxx:2079
 TClass.cxx:2080
 TClass.cxx:2081
 TClass.cxx:2082
 TClass.cxx:2083
 TClass.cxx:2084
 TClass.cxx:2085
 TClass.cxx:2086
 TClass.cxx:2087
 TClass.cxx:2088
 TClass.cxx:2089
 TClass.cxx:2090
 TClass.cxx:2091
 TClass.cxx:2092
 TClass.cxx:2093
 TClass.cxx:2094
 TClass.cxx:2095
 TClass.cxx:2096
 TClass.cxx:2097
 TClass.cxx:2098
 TClass.cxx:2099
 TClass.cxx:2100
 TClass.cxx:2101
 TClass.cxx:2102
 TClass.cxx:2103
 TClass.cxx:2104
 TClass.cxx:2105
 TClass.cxx:2106
 TClass.cxx:2107
 TClass.cxx:2108
 TClass.cxx:2109
 TClass.cxx:2110
 TClass.cxx:2111
 TClass.cxx:2112
 TClass.cxx:2113
 TClass.cxx:2114
 TClass.cxx:2115
 TClass.cxx:2116
 TClass.cxx:2117
 TClass.cxx:2118
 TClass.cxx:2119
 TClass.cxx:2120
 TClass.cxx:2121
 TClass.cxx:2122
 TClass.cxx:2123
 TClass.cxx:2124
 TClass.cxx:2125
 TClass.cxx:2126
 TClass.cxx:2127
 TClass.cxx:2128
 TClass.cxx:2129
 TClass.cxx:2130
 TClass.cxx:2131
 TClass.cxx:2132
 TClass.cxx:2133
 TClass.cxx:2134
 TClass.cxx:2135
 TClass.cxx:2136
 TClass.cxx:2137
 TClass.cxx:2138
 TClass.cxx:2139
 TClass.cxx:2140
 TClass.cxx:2141
 TClass.cxx:2142
 TClass.cxx:2143
 TClass.cxx:2144
 TClass.cxx:2145
 TClass.cxx:2146
 TClass.cxx:2147
 TClass.cxx:2148
 TClass.cxx:2149
 TClass.cxx:2150
 TClass.cxx:2151
 TClass.cxx:2152
 TClass.cxx:2153
 TClass.cxx:2154
 TClass.cxx:2155
 TClass.cxx:2156
 TClass.cxx:2157
 TClass.cxx:2158
 TClass.cxx:2159
 TClass.cxx:2160
 TClass.cxx:2161
 TClass.cxx:2162
 TClass.cxx:2163
 TClass.cxx:2164
 TClass.cxx:2165
 TClass.cxx:2166
 TClass.cxx:2167
 TClass.cxx:2168
 TClass.cxx:2169
 TClass.cxx:2170
 TClass.cxx:2171
 TClass.cxx:2172
 TClass.cxx:2173
 TClass.cxx:2174
 TClass.cxx:2175
 TClass.cxx:2176
 TClass.cxx:2177
 TClass.cxx:2178
 TClass.cxx:2179
 TClass.cxx:2180
 TClass.cxx:2181
 TClass.cxx:2182
 TClass.cxx:2183
 TClass.cxx:2184
 TClass.cxx:2185
 TClass.cxx:2186
 TClass.cxx:2187
 TClass.cxx:2188
 TClass.cxx:2189
 TClass.cxx:2190
 TClass.cxx:2191
 TClass.cxx:2192
 TClass.cxx:2193
 TClass.cxx:2194
 TClass.cxx:2195
 TClass.cxx:2196
 TClass.cxx:2197
 TClass.cxx:2198
 TClass.cxx:2199
 TClass.cxx:2200
 TClass.cxx:2201
 TClass.cxx:2202
 TClass.cxx:2203
 TClass.cxx:2204
 TClass.cxx:2205
 TClass.cxx:2206
 TClass.cxx:2207
 TClass.cxx:2208
 TClass.cxx:2209
 TClass.cxx:2210
 TClass.cxx:2211
 TClass.cxx:2212
 TClass.cxx:2213
 TClass.cxx:2214
 TClass.cxx:2215
 TClass.cxx:2216
 TClass.cxx:2217
 TClass.cxx:2218
 TClass.cxx:2219
 TClass.cxx:2220
 TClass.cxx:2221
 TClass.cxx:2222
 TClass.cxx:2223
 TClass.cxx:2224
 TClass.cxx:2225
 TClass.cxx:2226
 TClass.cxx:2227
 TClass.cxx:2228
 TClass.cxx:2229
 TClass.cxx:2230
 TClass.cxx:2231
 TClass.cxx:2232
 TClass.cxx:2233
 TClass.cxx:2234
 TClass.cxx:2235
 TClass.cxx:2236
 TClass.cxx:2237
 TClass.cxx:2238
 TClass.cxx:2239
 TClass.cxx:2240
 TClass.cxx:2241
 TClass.cxx:2242
 TClass.cxx:2243
 TClass.cxx:2244
 TClass.cxx:2245
 TClass.cxx:2246
 TClass.cxx:2247
 TClass.cxx:2248
 TClass.cxx:2249
 TClass.cxx:2250
 TClass.cxx:2251
 TClass.cxx:2252
 TClass.cxx:2253
 TClass.cxx:2254
 TClass.cxx:2255
 TClass.cxx:2256
 TClass.cxx:2257
 TClass.cxx:2258
 TClass.cxx:2259
 TClass.cxx:2260
 TClass.cxx:2261
 TClass.cxx:2262
 TClass.cxx:2263
 TClass.cxx:2264
 TClass.cxx:2265
 TClass.cxx:2266
 TClass.cxx:2267
 TClass.cxx:2268
 TClass.cxx:2269
 TClass.cxx:2270
 TClass.cxx:2271
 TClass.cxx:2272
 TClass.cxx:2273
 TClass.cxx:2274
 TClass.cxx:2275
 TClass.cxx:2276
 TClass.cxx:2277
 TClass.cxx:2278
 TClass.cxx:2279
 TClass.cxx:2280
 TClass.cxx:2281
 TClass.cxx:2282
 TClass.cxx:2283
 TClass.cxx:2284
 TClass.cxx:2285
 TClass.cxx:2286
 TClass.cxx:2287
 TClass.cxx:2288
 TClass.cxx:2289
 TClass.cxx:2290
 TClass.cxx:2291
 TClass.cxx:2292
 TClass.cxx:2293
 TClass.cxx:2294
 TClass.cxx:2295
 TClass.cxx:2296
 TClass.cxx:2297
 TClass.cxx:2298
 TClass.cxx:2299
 TClass.cxx:2300
 TClass.cxx:2301
 TClass.cxx:2302
 TClass.cxx:2303
 TClass.cxx:2304
 TClass.cxx:2305
 TClass.cxx:2306
 TClass.cxx:2307
 TClass.cxx:2308
 TClass.cxx:2309
 TClass.cxx:2310
 TClass.cxx:2311
 TClass.cxx:2312
 TClass.cxx:2313
 TClass.cxx:2314
 TClass.cxx:2315
 TClass.cxx:2316
 TClass.cxx:2317
 TClass.cxx:2318
 TClass.cxx:2319
 TClass.cxx:2320
 TClass.cxx:2321
 TClass.cxx:2322
 TClass.cxx:2323
 TClass.cxx:2324
 TClass.cxx:2325
 TClass.cxx:2326
 TClass.cxx:2327
 TClass.cxx:2328
 TClass.cxx:2329
 TClass.cxx:2330
 TClass.cxx:2331
 TClass.cxx:2332
 TClass.cxx:2333
 TClass.cxx:2334
 TClass.cxx:2335
 TClass.cxx:2336
 TClass.cxx:2337
 TClass.cxx:2338
 TClass.cxx:2339
 TClass.cxx:2340
 TClass.cxx:2341
 TClass.cxx:2342
 TClass.cxx:2343
 TClass.cxx:2344
 TClass.cxx:2345
 TClass.cxx:2346
 TClass.cxx:2347
 TClass.cxx:2348
 TClass.cxx:2349
 TClass.cxx:2350
 TClass.cxx:2351
 TClass.cxx:2352
 TClass.cxx:2353
 TClass.cxx:2354
 TClass.cxx:2355
 TClass.cxx:2356
 TClass.cxx:2357
 TClass.cxx:2358
 TClass.cxx:2359
 TClass.cxx:2360
 TClass.cxx:2361
 TClass.cxx:2362
 TClass.cxx:2363
 TClass.cxx:2364
 TClass.cxx:2365
 TClass.cxx:2366
 TClass.cxx:2367
 TClass.cxx:2368
 TClass.cxx:2369
 TClass.cxx:2370
 TClass.cxx:2371
 TClass.cxx:2372
 TClass.cxx:2373
 TClass.cxx:2374
 TClass.cxx:2375
 TClass.cxx:2376
 TClass.cxx:2377
 TClass.cxx:2378
 TClass.cxx:2379
 TClass.cxx:2380
 TClass.cxx:2381
 TClass.cxx:2382
 TClass.cxx:2383
 TClass.cxx:2384
 TClass.cxx:2385
 TClass.cxx:2386
 TClass.cxx:2387
 TClass.cxx:2388
 TClass.cxx:2389
 TClass.cxx:2390
 TClass.cxx:2391
 TClass.cxx:2392
 TClass.cxx:2393
 TClass.cxx:2394
 TClass.cxx:2395
 TClass.cxx:2396
 TClass.cxx:2397
 TClass.cxx:2398
 TClass.cxx:2399
 TClass.cxx:2400
 TClass.cxx:2401
 TClass.cxx:2402
 TClass.cxx:2403
 TClass.cxx:2404
 TClass.cxx:2405
 TClass.cxx:2406
 TClass.cxx:2407
 TClass.cxx:2408
 TClass.cxx:2409
 TClass.cxx:2410
 TClass.cxx:2411
 TClass.cxx:2412
 TClass.cxx:2413
 TClass.cxx:2414
 TClass.cxx:2415
 TClass.cxx:2416
 TClass.cxx:2417
 TClass.cxx:2418
 TClass.cxx:2419
 TClass.cxx:2420
 TClass.cxx:2421
 TClass.cxx:2422
 TClass.cxx:2423
 TClass.cxx:2424
 TClass.cxx:2425
 TClass.cxx:2426
 TClass.cxx:2427
 TClass.cxx:2428
 TClass.cxx:2429
 TClass.cxx:2430
 TClass.cxx:2431
 TClass.cxx:2432
 TClass.cxx:2433
 TClass.cxx:2434
 TClass.cxx:2435
 TClass.cxx:2436
 TClass.cxx:2437
 TClass.cxx:2438
 TClass.cxx:2439
 TClass.cxx:2440
 TClass.cxx:2441
 TClass.cxx:2442
 TClass.cxx:2443
 TClass.cxx:2444
 TClass.cxx:2445
 TClass.cxx:2446
 TClass.cxx:2447
 TClass.cxx:2448
 TClass.cxx:2449
 TClass.cxx:2450
 TClass.cxx:2451
 TClass.cxx:2452
 TClass.cxx:2453
 TClass.cxx:2454
 TClass.cxx:2455
 TClass.cxx:2456
 TClass.cxx:2457
 TClass.cxx:2458
 TClass.cxx:2459
 TClass.cxx:2460
 TClass.cxx:2461
 TClass.cxx:2462
 TClass.cxx:2463
 TClass.cxx:2464
 TClass.cxx:2465
 TClass.cxx:2466
 TClass.cxx:2467
 TClass.cxx:2468
 TClass.cxx:2469
 TClass.cxx:2470
 TClass.cxx:2471
 TClass.cxx:2472
 TClass.cxx:2473
 TClass.cxx:2474
 TClass.cxx:2475
 TClass.cxx:2476
 TClass.cxx:2477
 TClass.cxx:2478
 TClass.cxx:2479
 TClass.cxx:2480
 TClass.cxx:2481
 TClass.cxx:2482
 TClass.cxx:2483
 TClass.cxx:2484
 TClass.cxx:2485
 TClass.cxx:2486
 TClass.cxx:2487
 TClass.cxx:2488
 TClass.cxx:2489
 TClass.cxx:2490
 TClass.cxx:2491
 TClass.cxx:2492
 TClass.cxx:2493
 TClass.cxx:2494
 TClass.cxx:2495
 TClass.cxx:2496
 TClass.cxx:2497
 TClass.cxx:2498
 TClass.cxx:2499
 TClass.cxx:2500
 TClass.cxx:2501
 TClass.cxx:2502
 TClass.cxx:2503
 TClass.cxx:2504
 TClass.cxx:2505
 TClass.cxx:2506
 TClass.cxx:2507
 TClass.cxx:2508
 TClass.cxx:2509
 TClass.cxx:2510
 TClass.cxx:2511
 TClass.cxx:2512
 TClass.cxx:2513
 TClass.cxx:2514
 TClass.cxx:2515
 TClass.cxx:2516
 TClass.cxx:2517
 TClass.cxx:2518
 TClass.cxx:2519
 TClass.cxx:2520
 TClass.cxx:2521
 TClass.cxx:2522
 TClass.cxx:2523
 TClass.cxx:2524
 TClass.cxx:2525
 TClass.cxx:2526
 TClass.cxx:2527
 TClass.cxx:2528
 TClass.cxx:2529
 TClass.cxx:2530
 TClass.cxx:2531
 TClass.cxx:2532
 TClass.cxx:2533
 TClass.cxx:2534
 TClass.cxx:2535
 TClass.cxx:2536
 TClass.cxx:2537
 TClass.cxx:2538
 TClass.cxx:2539
 TClass.cxx:2540
 TClass.cxx:2541
 TClass.cxx:2542
 TClass.cxx:2543
 TClass.cxx:2544
 TClass.cxx:2545
 TClass.cxx:2546
 TClass.cxx:2547
 TClass.cxx:2548
 TClass.cxx:2549
 TClass.cxx:2550
 TClass.cxx:2551
 TClass.cxx:2552
 TClass.cxx:2553
 TClass.cxx:2554
 TClass.cxx:2555
 TClass.cxx:2556
 TClass.cxx:2557
 TClass.cxx:2558
 TClass.cxx:2559
 TClass.cxx:2560
 TClass.cxx:2561
 TClass.cxx:2562
 TClass.cxx:2563
 TClass.cxx:2564
 TClass.cxx:2565
 TClass.cxx:2566
 TClass.cxx:2567
 TClass.cxx:2568
 TClass.cxx:2569
 TClass.cxx:2570
 TClass.cxx:2571
 TClass.cxx:2572
 TClass.cxx:2573
 TClass.cxx:2574
 TClass.cxx:2575
 TClass.cxx:2576
 TClass.cxx:2577
 TClass.cxx:2578
 TClass.cxx:2579
 TClass.cxx:2580
 TClass.cxx:2581
 TClass.cxx:2582
 TClass.cxx:2583
 TClass.cxx:2584
 TClass.cxx:2585
 TClass.cxx:2586
 TClass.cxx:2587
 TClass.cxx:2588
 TClass.cxx:2589
 TClass.cxx:2590
 TClass.cxx:2591
 TClass.cxx:2592
 TClass.cxx:2593
 TClass.cxx:2594
 TClass.cxx:2595
 TClass.cxx:2596
 TClass.cxx:2597
 TClass.cxx:2598
 TClass.cxx:2599
 TClass.cxx:2600
 TClass.cxx:2601
 TClass.cxx:2602
 TClass.cxx:2603
 TClass.cxx:2604
 TClass.cxx:2605
 TClass.cxx:2606
 TClass.cxx:2607
 TClass.cxx:2608
 TClass.cxx:2609
 TClass.cxx:2610
 TClass.cxx:2611
 TClass.cxx:2612
 TClass.cxx:2613
 TClass.cxx:2614
 TClass.cxx:2615
 TClass.cxx:2616
 TClass.cxx:2617
 TClass.cxx:2618
 TClass.cxx:2619
 TClass.cxx:2620
 TClass.cxx:2621
 TClass.cxx:2622
 TClass.cxx:2623
 TClass.cxx:2624
 TClass.cxx:2625
 TClass.cxx:2626
 TClass.cxx:2627
 TClass.cxx:2628
 TClass.cxx:2629
 TClass.cxx:2630
 TClass.cxx:2631
 TClass.cxx:2632
 TClass.cxx:2633
 TClass.cxx:2634
 TClass.cxx:2635
 TClass.cxx:2636
 TClass.cxx:2637
 TClass.cxx:2638
 TClass.cxx:2639
 TClass.cxx:2640
 TClass.cxx:2641
 TClass.cxx:2642
 TClass.cxx:2643
 TClass.cxx:2644
 TClass.cxx:2645
 TClass.cxx:2646
 TClass.cxx:2647
 TClass.cxx:2648
 TClass.cxx:2649
 TClass.cxx:2650
 TClass.cxx:2651
 TClass.cxx:2652
 TClass.cxx:2653
 TClass.cxx:2654
 TClass.cxx:2655
 TClass.cxx:2656
 TClass.cxx:2657
 TClass.cxx:2658
 TClass.cxx:2659
 TClass.cxx:2660
 TClass.cxx:2661
 TClass.cxx:2662
 TClass.cxx:2663
 TClass.cxx:2664
 TClass.cxx:2665
 TClass.cxx:2666
 TClass.cxx:2667
 TClass.cxx:2668
 TClass.cxx:2669
 TClass.cxx:2670
 TClass.cxx:2671
 TClass.cxx:2672
 TClass.cxx:2673
 TClass.cxx:2674
 TClass.cxx:2675
 TClass.cxx:2676
 TClass.cxx:2677
 TClass.cxx:2678
 TClass.cxx:2679
 TClass.cxx:2680
 TClass.cxx:2681
 TClass.cxx:2682
 TClass.cxx:2683
 TClass.cxx:2684
 TClass.cxx:2685
 TClass.cxx:2686
 TClass.cxx:2687
 TClass.cxx:2688
 TClass.cxx:2689
 TClass.cxx:2690
 TClass.cxx:2691
 TClass.cxx:2692
 TClass.cxx:2693
 TClass.cxx:2694
 TClass.cxx:2695
 TClass.cxx:2696
 TClass.cxx:2697
 TClass.cxx:2698
 TClass.cxx:2699
 TClass.cxx:2700
 TClass.cxx:2701
 TClass.cxx:2702
 TClass.cxx:2703
 TClass.cxx:2704
 TClass.cxx:2705
 TClass.cxx:2706
 TClass.cxx:2707
 TClass.cxx:2708
 TClass.cxx:2709
 TClass.cxx:2710
 TClass.cxx:2711
 TClass.cxx:2712
 TClass.cxx:2713
 TClass.cxx:2714
 TClass.cxx:2715
 TClass.cxx:2716
 TClass.cxx:2717
 TClass.cxx:2718
 TClass.cxx:2719
 TClass.cxx:2720
 TClass.cxx:2721
 TClass.cxx:2722
 TClass.cxx:2723
 TClass.cxx:2724
 TClass.cxx:2725
 TClass.cxx:2726
 TClass.cxx:2727
 TClass.cxx:2728
 TClass.cxx:2729
 TClass.cxx:2730
 TClass.cxx:2731
 TClass.cxx:2732
 TClass.cxx:2733
 TClass.cxx:2734
 TClass.cxx:2735
 TClass.cxx:2736
 TClass.cxx:2737
 TClass.cxx:2738
 TClass.cxx:2739
 TClass.cxx:2740
 TClass.cxx:2741
 TClass.cxx:2742
 TClass.cxx:2743
 TClass.cxx:2744
 TClass.cxx:2745
 TClass.cxx:2746
 TClass.cxx:2747
 TClass.cxx:2748
 TClass.cxx:2749
 TClass.cxx:2750
 TClass.cxx:2751
 TClass.cxx:2752
 TClass.cxx:2753
 TClass.cxx:2754
 TClass.cxx:2755
 TClass.cxx:2756
 TClass.cxx:2757
 TClass.cxx:2758
 TClass.cxx:2759
 TClass.cxx:2760
 TClass.cxx:2761
 TClass.cxx:2762
 TClass.cxx:2763
 TClass.cxx:2764
 TClass.cxx:2765
 TClass.cxx:2766
 TClass.cxx:2767
 TClass.cxx:2768
 TClass.cxx:2769
 TClass.cxx:2770
 TClass.cxx:2771
 TClass.cxx:2772
 TClass.cxx:2773
 TClass.cxx:2774
 TClass.cxx:2775
 TClass.cxx:2776
 TClass.cxx:2777
 TClass.cxx:2778
 TClass.cxx:2779
 TClass.cxx:2780
 TClass.cxx:2781
 TClass.cxx:2782
 TClass.cxx:2783
 TClass.cxx:2784
 TClass.cxx:2785
 TClass.cxx:2786
 TClass.cxx:2787
 TClass.cxx:2788
 TClass.cxx:2789
 TClass.cxx:2790
 TClass.cxx:2791
 TClass.cxx:2792
 TClass.cxx:2793
 TClass.cxx:2794
 TClass.cxx:2795
 TClass.cxx:2796
 TClass.cxx:2797
 TClass.cxx:2798
 TClass.cxx:2799
 TClass.cxx:2800
 TClass.cxx:2801
 TClass.cxx:2802
 TClass.cxx:2803
 TClass.cxx:2804
 TClass.cxx:2805
 TClass.cxx:2806
 TClass.cxx:2807
 TClass.cxx:2808
 TClass.cxx:2809
 TClass.cxx:2810
 TClass.cxx:2811
 TClass.cxx:2812
 TClass.cxx:2813
 TClass.cxx:2814
 TClass.cxx:2815
 TClass.cxx:2816
 TClass.cxx:2817
 TClass.cxx:2818
 TClass.cxx:2819
 TClass.cxx:2820
 TClass.cxx:2821
 TClass.cxx:2822
 TClass.cxx:2823
 TClass.cxx:2824
 TClass.cxx:2825
 TClass.cxx:2826
 TClass.cxx:2827
 TClass.cxx:2828
 TClass.cxx:2829
 TClass.cxx:2830
 TClass.cxx:2831
 TClass.cxx:2832
 TClass.cxx:2833
 TClass.cxx:2834
 TClass.cxx:2835
 TClass.cxx:2836
 TClass.cxx:2837
 TClass.cxx:2838
 TClass.cxx:2839
 TClass.cxx:2840
 TClass.cxx:2841
 TClass.cxx:2842
 TClass.cxx:2843
 TClass.cxx:2844
 TClass.cxx:2845
 TClass.cxx:2846
 TClass.cxx:2847
 TClass.cxx:2848
 TClass.cxx:2849
 TClass.cxx:2850
 TClass.cxx:2851
 TClass.cxx:2852
 TClass.cxx:2853
 TClass.cxx:2854
 TClass.cxx:2855
 TClass.cxx:2856
 TClass.cxx:2857
 TClass.cxx:2858
 TClass.cxx:2859
 TClass.cxx:2860
 TClass.cxx:2861
 TClass.cxx:2862
 TClass.cxx:2863
 TClass.cxx:2864
 TClass.cxx:2865
 TClass.cxx:2866
 TClass.cxx:2867
 TClass.cxx:2868
 TClass.cxx:2869
 TClass.cxx:2870
 TClass.cxx:2871
 TClass.cxx:2872
 TClass.cxx:2873
 TClass.cxx:2874
 TClass.cxx:2875
 TClass.cxx:2876
 TClass.cxx:2877
 TClass.cxx:2878
 TClass.cxx:2879
 TClass.cxx:2880
 TClass.cxx:2881
 TClass.cxx:2882
 TClass.cxx:2883
 TClass.cxx:2884
 TClass.cxx:2885
 TClass.cxx:2886
 TClass.cxx:2887
 TClass.cxx:2888
 TClass.cxx:2889
 TClass.cxx:2890
 TClass.cxx:2891
 TClass.cxx:2892
 TClass.cxx:2893
 TClass.cxx:2894
 TClass.cxx:2895
 TClass.cxx:2896
 TClass.cxx:2897
 TClass.cxx:2898
 TClass.cxx:2899
 TClass.cxx:2900
 TClass.cxx:2901
 TClass.cxx:2902
 TClass.cxx:2903
 TClass.cxx:2904
 TClass.cxx:2905
 TClass.cxx:2906
 TClass.cxx:2907
 TClass.cxx:2908
 TClass.cxx:2909
 TClass.cxx:2910
 TClass.cxx:2911
 TClass.cxx:2912
 TClass.cxx:2913
 TClass.cxx:2914
 TClass.cxx:2915
 TClass.cxx:2916
 TClass.cxx:2917
 TClass.cxx:2918
 TClass.cxx:2919
 TClass.cxx:2920
 TClass.cxx:2921
 TClass.cxx:2922
 TClass.cxx:2923
 TClass.cxx:2924
 TClass.cxx:2925
 TClass.cxx:2926
 TClass.cxx:2927
 TClass.cxx:2928
 TClass.cxx:2929
 TClass.cxx:2930
 TClass.cxx:2931
 TClass.cxx:2932
 TClass.cxx:2933
 TClass.cxx:2934
 TClass.cxx:2935
 TClass.cxx:2936
 TClass.cxx:2937
 TClass.cxx:2938
 TClass.cxx:2939
 TClass.cxx:2940
 TClass.cxx:2941
 TClass.cxx:2942
 TClass.cxx:2943
 TClass.cxx:2944
 TClass.cxx:2945
 TClass.cxx:2946
 TClass.cxx:2947
 TClass.cxx:2948
 TClass.cxx:2949
 TClass.cxx:2950
 TClass.cxx:2951
 TClass.cxx:2952
 TClass.cxx:2953
 TClass.cxx:2954
 TClass.cxx:2955
 TClass.cxx:2956
 TClass.cxx:2957
 TClass.cxx:2958
 TClass.cxx:2959
 TClass.cxx:2960
 TClass.cxx:2961
 TClass.cxx:2962
 TClass.cxx:2963
 TClass.cxx:2964
 TClass.cxx:2965
 TClass.cxx:2966
 TClass.cxx:2967
 TClass.cxx:2968
 TClass.cxx:2969
 TClass.cxx:2970
 TClass.cxx:2971
 TClass.cxx:2972
 TClass.cxx:2973
 TClass.cxx:2974
 TClass.cxx:2975
 TClass.cxx:2976
 TClass.cxx:2977
 TClass.cxx:2978
 TClass.cxx:2979
 TClass.cxx:2980
 TClass.cxx:2981
 TClass.cxx:2982
 TClass.cxx:2983
 TClass.cxx:2984
 TClass.cxx:2985
 TClass.cxx:2986
 TClass.cxx:2987
 TClass.cxx:2988
 TClass.cxx:2989
 TClass.cxx:2990
 TClass.cxx:2991
 TClass.cxx:2992
 TClass.cxx:2993
 TClass.cxx:2994
 TClass.cxx:2995
 TClass.cxx:2996
 TClass.cxx:2997
 TClass.cxx:2998
 TClass.cxx:2999
 TClass.cxx:3000
 TClass.cxx:3001
 TClass.cxx:3002
 TClass.cxx:3003
 TClass.cxx:3004
 TClass.cxx:3005
 TClass.cxx:3006
 TClass.cxx:3007
 TClass.cxx:3008
 TClass.cxx:3009
 TClass.cxx:3010
 TClass.cxx:3011
 TClass.cxx:3012
 TClass.cxx:3013
 TClass.cxx:3014
 TClass.cxx:3015
 TClass.cxx:3016
 TClass.cxx:3017
 TClass.cxx:3018
 TClass.cxx:3019
 TClass.cxx:3020
 TClass.cxx:3021
 TClass.cxx:3022
 TClass.cxx:3023
 TClass.cxx:3024
 TClass.cxx:3025
 TClass.cxx:3026
 TClass.cxx:3027
 TClass.cxx:3028
 TClass.cxx:3029
 TClass.cxx:3030
 TClass.cxx:3031
 TClass.cxx:3032
 TClass.cxx:3033
 TClass.cxx:3034
 TClass.cxx:3035
 TClass.cxx:3036
 TClass.cxx:3037
 TClass.cxx:3038
 TClass.cxx:3039
 TClass.cxx:3040
 TClass.cxx:3041
 TClass.cxx:3042
 TClass.cxx:3043
 TClass.cxx:3044
 TClass.cxx:3045
 TClass.cxx:3046
 TClass.cxx:3047
 TClass.cxx:3048
 TClass.cxx:3049
 TClass.cxx:3050
 TClass.cxx:3051
 TClass.cxx:3052
 TClass.cxx:3053
 TClass.cxx:3054
 TClass.cxx:3055
 TClass.cxx:3056
 TClass.cxx:3057
 TClass.cxx:3058
 TClass.cxx:3059
 TClass.cxx:3060
 TClass.cxx:3061
 TClass.cxx:3062
 TClass.cxx:3063
 TClass.cxx:3064
 TClass.cxx:3065
 TClass.cxx:3066
 TClass.cxx:3067
 TClass.cxx:3068
 TClass.cxx:3069
 TClass.cxx:3070
 TClass.cxx:3071
 TClass.cxx:3072
 TClass.cxx:3073
 TClass.cxx:3074
 TClass.cxx:3075
 TClass.cxx:3076
 TClass.cxx:3077
 TClass.cxx:3078
 TClass.cxx:3079
 TClass.cxx:3080
 TClass.cxx:3081
 TClass.cxx:3082
 TClass.cxx:3083
 TClass.cxx:3084
 TClass.cxx:3085
 TClass.cxx:3086
 TClass.cxx:3087
 TClass.cxx:3088
 TClass.cxx:3089
 TClass.cxx:3090
 TClass.cxx:3091
 TClass.cxx:3092
 TClass.cxx:3093
 TClass.cxx:3094
 TClass.cxx:3095
 TClass.cxx:3096
 TClass.cxx:3097
 TClass.cxx:3098
 TClass.cxx:3099
 TClass.cxx:3100
 TClass.cxx:3101
 TClass.cxx:3102
 TClass.cxx:3103
 TClass.cxx:3104
 TClass.cxx:3105
 TClass.cxx:3106
 TClass.cxx:3107
 TClass.cxx:3108
 TClass.cxx:3109
 TClass.cxx:3110
 TClass.cxx:3111
 TClass.cxx:3112
 TClass.cxx:3113
 TClass.cxx:3114
 TClass.cxx:3115
 TClass.cxx:3116
 TClass.cxx:3117
 TClass.cxx:3118
 TClass.cxx:3119
 TClass.cxx:3120
 TClass.cxx:3121
 TClass.cxx:3122
 TClass.cxx:3123
 TClass.cxx:3124
 TClass.cxx:3125
 TClass.cxx:3126
 TClass.cxx:3127
 TClass.cxx:3128
 TClass.cxx:3129
 TClass.cxx:3130
 TClass.cxx:3131
 TClass.cxx:3132
 TClass.cxx:3133
 TClass.cxx:3134
 TClass.cxx:3135
 TClass.cxx:3136
 TClass.cxx:3137
 TClass.cxx:3138
 TClass.cxx:3139
 TClass.cxx:3140
 TClass.cxx:3141
 TClass.cxx:3142
 TClass.cxx:3143
 TClass.cxx:3144
 TClass.cxx:3145
 TClass.cxx:3146
 TClass.cxx:3147
 TClass.cxx:3148
 TClass.cxx:3149
 TClass.cxx:3150
 TClass.cxx:3151
 TClass.cxx:3152
 TClass.cxx:3153
 TClass.cxx:3154
 TClass.cxx:3155
 TClass.cxx:3156
 TClass.cxx:3157
 TClass.cxx:3158
 TClass.cxx:3159
 TClass.cxx:3160
 TClass.cxx:3161
 TClass.cxx:3162
 TClass.cxx:3163
 TClass.cxx:3164
 TClass.cxx:3165
 TClass.cxx:3166
 TClass.cxx:3167
 TClass.cxx:3168
 TClass.cxx:3169
 TClass.cxx:3170
 TClass.cxx:3171
 TClass.cxx:3172
 TClass.cxx:3173
 TClass.cxx:3174
 TClass.cxx:3175
 TClass.cxx:3176
 TClass.cxx:3177
 TClass.cxx:3178
 TClass.cxx:3179
 TClass.cxx:3180
 TClass.cxx:3181
 TClass.cxx:3182
 TClass.cxx:3183
 TClass.cxx:3184
 TClass.cxx:3185
 TClass.cxx:3186
 TClass.cxx:3187
 TClass.cxx:3188
 TClass.cxx:3189
 TClass.cxx:3190
 TClass.cxx:3191
 TClass.cxx:3192
 TClass.cxx:3193
 TClass.cxx:3194
 TClass.cxx:3195
 TClass.cxx:3196
 TClass.cxx:3197
 TClass.cxx:3198
 TClass.cxx:3199
 TClass.cxx:3200
 TClass.cxx:3201
 TClass.cxx:3202
 TClass.cxx:3203
 TClass.cxx:3204
 TClass.cxx:3205
 TClass.cxx:3206
 TClass.cxx:3207
 TClass.cxx:3208
 TClass.cxx:3209
 TClass.cxx:3210
 TClass.cxx:3211
 TClass.cxx:3212
 TClass.cxx:3213
 TClass.cxx:3214
 TClass.cxx:3215
 TClass.cxx:3216
 TClass.cxx:3217
 TClass.cxx:3218
 TClass.cxx:3219
 TClass.cxx:3220
 TClass.cxx:3221
 TClass.cxx:3222
 TClass.cxx:3223
 TClass.cxx:3224
 TClass.cxx:3225
 TClass.cxx:3226
 TClass.cxx:3227
 TClass.cxx:3228
 TClass.cxx:3229
 TClass.cxx:3230
 TClass.cxx:3231
 TClass.cxx:3232
 TClass.cxx:3233
 TClass.cxx:3234
 TClass.cxx:3235
 TClass.cxx:3236
 TClass.cxx:3237
 TClass.cxx:3238
 TClass.cxx:3239
 TClass.cxx:3240
 TClass.cxx:3241
 TClass.cxx:3242
 TClass.cxx:3243
 TClass.cxx:3244
 TClass.cxx:3245
 TClass.cxx:3246
 TClass.cxx:3247
 TClass.cxx:3248
 TClass.cxx:3249
 TClass.cxx:3250
 TClass.cxx:3251
 TClass.cxx:3252
 TClass.cxx:3253
 TClass.cxx:3254
 TClass.cxx:3255
 TClass.cxx:3256
 TClass.cxx:3257
 TClass.cxx:3258
 TClass.cxx:3259
 TClass.cxx:3260
 TClass.cxx:3261
 TClass.cxx:3262
 TClass.cxx:3263
 TClass.cxx:3264
 TClass.cxx:3265
 TClass.cxx:3266
 TClass.cxx:3267
 TClass.cxx:3268
 TClass.cxx:3269
 TClass.cxx:3270
 TClass.cxx:3271
 TClass.cxx:3272
 TClass.cxx:3273
 TClass.cxx:3274
 TClass.cxx:3275
 TClass.cxx:3276
 TClass.cxx:3277
 TClass.cxx:3278
 TClass.cxx:3279
 TClass.cxx:3280
 TClass.cxx:3281
 TClass.cxx:3282
 TClass.cxx:3283
 TClass.cxx:3284
 TClass.cxx:3285
 TClass.cxx:3286
 TClass.cxx:3287
 TClass.cxx:3288
 TClass.cxx:3289
 TClass.cxx:3290
 TClass.cxx:3291
 TClass.cxx:3292
 TClass.cxx:3293
 TClass.cxx:3294
 TClass.cxx:3295
 TClass.cxx:3296
 TClass.cxx:3297
 TClass.cxx:3298
 TClass.cxx:3299
 TClass.cxx:3300
 TClass.cxx:3301
 TClass.cxx:3302
 TClass.cxx:3303
 TClass.cxx:3304
 TClass.cxx:3305
 TClass.cxx:3306
 TClass.cxx:3307
 TClass.cxx:3308
 TClass.cxx:3309
 TClass.cxx:3310
 TClass.cxx:3311
 TClass.cxx:3312
 TClass.cxx:3313
 TClass.cxx:3314
 TClass.cxx:3315
 TClass.cxx:3316
 TClass.cxx:3317
 TClass.cxx:3318
 TClass.cxx:3319
 TClass.cxx:3320
 TClass.cxx:3321
 TClass.cxx:3322
 TClass.cxx:3323
 TClass.cxx:3324
 TClass.cxx:3325
 TClass.cxx:3326
 TClass.cxx:3327
 TClass.cxx:3328
 TClass.cxx:3329
 TClass.cxx:3330
 TClass.cxx:3331
 TClass.cxx:3332
 TClass.cxx:3333
 TClass.cxx:3334
 TClass.cxx:3335
 TClass.cxx:3336
 TClass.cxx:3337
 TClass.cxx:3338
 TClass.cxx:3339
 TClass.cxx:3340
 TClass.cxx:3341
 TClass.cxx:3342
 TClass.cxx:3343
 TClass.cxx:3344
 TClass.cxx:3345
 TClass.cxx:3346
 TClass.cxx:3347
 TClass.cxx:3348
 TClass.cxx:3349
 TClass.cxx:3350
 TClass.cxx:3351
 TClass.cxx:3352
 TClass.cxx:3353
 TClass.cxx:3354
 TClass.cxx:3355
 TClass.cxx:3356
 TClass.cxx:3357
 TClass.cxx:3358
 TClass.cxx:3359
 TClass.cxx:3360
 TClass.cxx:3361
 TClass.cxx:3362
 TClass.cxx:3363
 TClass.cxx:3364
 TClass.cxx:3365
 TClass.cxx:3366
 TClass.cxx:3367
 TClass.cxx:3368
 TClass.cxx:3369
 TClass.cxx:3370
 TClass.cxx:3371
 TClass.cxx:3372
 TClass.cxx:3373
 TClass.cxx:3374
 TClass.cxx:3375
 TClass.cxx:3376
 TClass.cxx:3377
 TClass.cxx:3378
 TClass.cxx:3379
 TClass.cxx:3380
 TClass.cxx:3381
 TClass.cxx:3382
 TClass.cxx:3383
 TClass.cxx:3384
 TClass.cxx:3385
 TClass.cxx:3386
 TClass.cxx:3387
 TClass.cxx:3388
 TClass.cxx:3389
 TClass.cxx:3390
 TClass.cxx:3391
 TClass.cxx:3392
 TClass.cxx:3393
 TClass.cxx:3394
 TClass.cxx:3395
 TClass.cxx:3396
 TClass.cxx:3397
 TClass.cxx:3398
 TClass.cxx:3399
 TClass.cxx:3400
 TClass.cxx:3401
 TClass.cxx:3402
 TClass.cxx:3403
 TClass.cxx:3404
 TClass.cxx:3405
 TClass.cxx:3406
 TClass.cxx:3407
 TClass.cxx:3408
 TClass.cxx:3409
 TClass.cxx:3410
 TClass.cxx:3411
 TClass.cxx:3412
 TClass.cxx:3413
 TClass.cxx:3414
 TClass.cxx:3415
 TClass.cxx:3416
 TClass.cxx:3417
 TClass.cxx:3418
 TClass.cxx:3419
 TClass.cxx:3420
 TClass.cxx:3421
 TClass.cxx:3422
 TClass.cxx:3423
 TClass.cxx:3424
 TClass.cxx:3425
 TClass.cxx:3426
 TClass.cxx:3427
 TClass.cxx:3428
 TClass.cxx:3429
 TClass.cxx:3430
 TClass.cxx:3431
 TClass.cxx:3432
 TClass.cxx:3433
 TClass.cxx:3434
 TClass.cxx:3435
 TClass.cxx:3436
 TClass.cxx:3437
 TClass.cxx:3438
 TClass.cxx:3439
 TClass.cxx:3440
 TClass.cxx:3441
 TClass.cxx:3442
 TClass.cxx:3443
 TClass.cxx:3444
 TClass.cxx:3445
 TClass.cxx:3446
 TClass.cxx:3447
 TClass.cxx:3448
 TClass.cxx:3449
 TClass.cxx:3450
 TClass.cxx:3451
 TClass.cxx:3452
 TClass.cxx:3453
 TClass.cxx:3454
 TClass.cxx:3455
 TClass.cxx:3456
 TClass.cxx:3457
 TClass.cxx:3458
 TClass.cxx:3459
 TClass.cxx:3460
 TClass.cxx:3461
 TClass.cxx:3462
 TClass.cxx:3463
 TClass.cxx:3464
 TClass.cxx:3465
 TClass.cxx:3466
 TClass.cxx:3467
 TClass.cxx:3468
 TClass.cxx:3469
 TClass.cxx:3470
 TClass.cxx:3471
 TClass.cxx:3472
 TClass.cxx:3473
 TClass.cxx:3474
 TClass.cxx:3475
 TClass.cxx:3476
 TClass.cxx:3477
 TClass.cxx:3478
 TClass.cxx:3479
 TClass.cxx:3480
 TClass.cxx:3481
 TClass.cxx:3482
 TClass.cxx:3483
 TClass.cxx:3484
 TClass.cxx:3485
 TClass.cxx:3486
 TClass.cxx:3487
 TClass.cxx:3488
 TClass.cxx:3489
 TClass.cxx:3490
 TClass.cxx:3491
 TClass.cxx:3492
 TClass.cxx:3493
 TClass.cxx:3494
 TClass.cxx:3495
 TClass.cxx:3496
 TClass.cxx:3497
 TClass.cxx:3498
 TClass.cxx:3499
 TClass.cxx:3500
 TClass.cxx:3501
 TClass.cxx:3502
 TClass.cxx:3503
 TClass.cxx:3504
 TClass.cxx:3505
 TClass.cxx:3506
 TClass.cxx:3507
 TClass.cxx:3508
 TClass.cxx:3509
 TClass.cxx:3510
 TClass.cxx:3511
 TClass.cxx:3512
 TClass.cxx:3513
 TClass.cxx:3514
 TClass.cxx:3515
 TClass.cxx:3516
 TClass.cxx:3517
 TClass.cxx:3518
 TClass.cxx:3519
 TClass.cxx:3520
 TClass.cxx:3521
 TClass.cxx:3522
 TClass.cxx:3523
 TClass.cxx:3524
 TClass.cxx:3525
 TClass.cxx:3526
 TClass.cxx:3527
 TClass.cxx:3528
 TClass.cxx:3529
 TClass.cxx:3530
 TClass.cxx:3531
 TClass.cxx:3532
 TClass.cxx:3533
 TClass.cxx:3534
 TClass.cxx:3535
 TClass.cxx:3536
 TClass.cxx:3537
 TClass.cxx:3538
 TClass.cxx:3539
 TClass.cxx:3540
 TClass.cxx:3541
 TClass.cxx:3542
 TClass.cxx:3543
 TClass.cxx:3544
 TClass.cxx:3545
 TClass.cxx:3546
 TClass.cxx:3547
 TClass.cxx:3548
 TClass.cxx:3549
 TClass.cxx:3550
 TClass.cxx:3551
 TClass.cxx:3552
 TClass.cxx:3553
 TClass.cxx:3554
 TClass.cxx:3555
 TClass.cxx:3556
 TClass.cxx:3557
 TClass.cxx:3558
 TClass.cxx:3559
 TClass.cxx:3560
 TClass.cxx:3561
 TClass.cxx:3562
 TClass.cxx:3563
 TClass.cxx:3564
 TClass.cxx:3565
 TClass.cxx:3566
 TClass.cxx:3567
 TClass.cxx:3568
 TClass.cxx:3569
 TClass.cxx:3570
 TClass.cxx:3571
 TClass.cxx:3572
 TClass.cxx:3573
 TClass.cxx:3574
 TClass.cxx:3575
 TClass.cxx:3576
 TClass.cxx:3577
 TClass.cxx:3578
 TClass.cxx:3579
 TClass.cxx:3580
 TClass.cxx:3581
 TClass.cxx:3582
 TClass.cxx:3583
 TClass.cxx:3584
 TClass.cxx:3585
 TClass.cxx:3586
 TClass.cxx:3587
 TClass.cxx:3588
 TClass.cxx:3589
 TClass.cxx:3590
 TClass.cxx:3591
 TClass.cxx:3592
 TClass.cxx:3593
 TClass.cxx:3594
 TClass.cxx:3595
 TClass.cxx:3596
 TClass.cxx:3597
 TClass.cxx:3598
 TClass.cxx:3599
 TClass.cxx:3600
 TClass.cxx:3601
 TClass.cxx:3602
 TClass.cxx:3603
 TClass.cxx:3604
 TClass.cxx:3605
 TClass.cxx:3606
 TClass.cxx:3607
 TClass.cxx:3608
 TClass.cxx:3609
 TClass.cxx:3610
 TClass.cxx:3611
 TClass.cxx:3612
 TClass.cxx:3613
 TClass.cxx:3614
 TClass.cxx:3615
 TClass.cxx:3616
 TClass.cxx:3617
 TClass.cxx:3618
 TClass.cxx:3619
 TClass.cxx:3620
 TClass.cxx:3621
 TClass.cxx:3622
 TClass.cxx:3623
 TClass.cxx:3624
 TClass.cxx:3625
 TClass.cxx:3626
 TClass.cxx:3627
 TClass.cxx:3628
 TClass.cxx:3629
 TClass.cxx:3630
 TClass.cxx:3631
 TClass.cxx:3632
 TClass.cxx:3633
 TClass.cxx:3634
 TClass.cxx:3635
 TClass.cxx:3636
 TClass.cxx:3637
 TClass.cxx:3638
 TClass.cxx:3639
 TClass.cxx:3640
 TClass.cxx:3641
 TClass.cxx:3642
 TClass.cxx:3643
 TClass.cxx:3644
 TClass.cxx:3645
 TClass.cxx:3646
 TClass.cxx:3647
 TClass.cxx:3648
 TClass.cxx:3649
 TClass.cxx:3650
 TClass.cxx:3651
 TClass.cxx:3652
 TClass.cxx:3653
 TClass.cxx:3654
 TClass.cxx:3655
 TClass.cxx:3656
 TClass.cxx:3657
 TClass.cxx:3658
 TClass.cxx:3659
 TClass.cxx:3660
 TClass.cxx:3661
 TClass.cxx:3662
 TClass.cxx:3663
 TClass.cxx:3664
 TClass.cxx:3665
 TClass.cxx:3666
 TClass.cxx:3667
 TClass.cxx:3668
 TClass.cxx:3669
 TClass.cxx:3670
 TClass.cxx:3671
 TClass.cxx:3672
 TClass.cxx:3673
 TClass.cxx:3674
 TClass.cxx:3675
 TClass.cxx:3676
 TClass.cxx:3677
 TClass.cxx:3678
 TClass.cxx:3679
 TClass.cxx:3680
 TClass.cxx:3681
 TClass.cxx:3682
 TClass.cxx:3683
 TClass.cxx:3684
 TClass.cxx:3685
 TClass.cxx:3686
 TClass.cxx:3687
 TClass.cxx:3688
 TClass.cxx:3689
 TClass.cxx:3690
 TClass.cxx:3691
 TClass.cxx:3692
 TClass.cxx:3693
 TClass.cxx:3694
 TClass.cxx:3695
 TClass.cxx:3696
 TClass.cxx:3697
 TClass.cxx:3698
 TClass.cxx:3699
 TClass.cxx:3700
 TClass.cxx:3701
 TClass.cxx:3702
 TClass.cxx:3703
 TClass.cxx:3704
 TClass.cxx:3705
 TClass.cxx:3706
 TClass.cxx:3707
 TClass.cxx:3708
 TClass.cxx:3709
 TClass.cxx:3710
 TClass.cxx:3711
 TClass.cxx:3712
 TClass.cxx:3713
 TClass.cxx:3714
 TClass.cxx:3715
 TClass.cxx:3716
 TClass.cxx:3717
 TClass.cxx:3718
 TClass.cxx:3719
 TClass.cxx:3720
 TClass.cxx:3721
 TClass.cxx:3722
 TClass.cxx:3723
 TClass.cxx:3724
 TClass.cxx:3725
 TClass.cxx:3726
 TClass.cxx:3727
 TClass.cxx:3728
 TClass.cxx:3729
 TClass.cxx:3730
 TClass.cxx:3731
 TClass.cxx:3732
 TClass.cxx:3733
 TClass.cxx:3734
 TClass.cxx:3735
 TClass.cxx:3736
 TClass.cxx:3737
 TClass.cxx:3738
 TClass.cxx:3739
 TClass.cxx:3740
 TClass.cxx:3741
 TClass.cxx:3742
 TClass.cxx:3743
 TClass.cxx:3744
 TClass.cxx:3745
 TClass.cxx:3746
 TClass.cxx:3747
 TClass.cxx:3748
 TClass.cxx:3749
 TClass.cxx:3750
 TClass.cxx:3751
 TClass.cxx:3752
 TClass.cxx:3753
 TClass.cxx:3754
 TClass.cxx:3755
 TClass.cxx:3756
 TClass.cxx:3757
 TClass.cxx:3758
 TClass.cxx:3759
 TClass.cxx:3760
 TClass.cxx:3761
 TClass.cxx:3762
 TClass.cxx:3763
 TClass.cxx:3764
 TClass.cxx:3765
 TClass.cxx:3766
 TClass.cxx:3767
 TClass.cxx:3768
 TClass.cxx:3769
 TClass.cxx:3770
 TClass.cxx:3771
 TClass.cxx:3772
 TClass.cxx:3773
 TClass.cxx:3774
 TClass.cxx:3775
 TClass.cxx:3776
 TClass.cxx:3777
 TClass.cxx:3778
 TClass.cxx:3779
 TClass.cxx:3780
 TClass.cxx:3781
 TClass.cxx:3782
 TClass.cxx:3783
 TClass.cxx:3784
 TClass.cxx:3785
 TClass.cxx:3786
 TClass.cxx:3787
 TClass.cxx:3788
 TClass.cxx:3789
 TClass.cxx:3790
 TClass.cxx:3791
 TClass.cxx:3792
 TClass.cxx:3793
 TClass.cxx:3794
 TClass.cxx:3795
 TClass.cxx:3796
 TClass.cxx:3797
 TClass.cxx:3798
 TClass.cxx:3799
 TClass.cxx:3800
 TClass.cxx:3801
 TClass.cxx:3802
 TClass.cxx:3803
 TClass.cxx:3804
 TClass.cxx:3805
 TClass.cxx:3806
 TClass.cxx:3807
 TClass.cxx:3808
 TClass.cxx:3809
 TClass.cxx:3810
 TClass.cxx:3811
 TClass.cxx:3812
 TClass.cxx:3813
 TClass.cxx:3814
 TClass.cxx:3815
 TClass.cxx:3816
 TClass.cxx:3817
 TClass.cxx:3818
 TClass.cxx:3819
 TClass.cxx:3820
 TClass.cxx:3821
 TClass.cxx:3822
 TClass.cxx:3823
 TClass.cxx:3824
 TClass.cxx:3825
 TClass.cxx:3826
 TClass.cxx:3827
 TClass.cxx:3828
 TClass.cxx:3829
 TClass.cxx:3830
 TClass.cxx:3831
 TClass.cxx:3832
 TClass.cxx:3833
 TClass.cxx:3834
 TClass.cxx:3835
 TClass.cxx:3836
 TClass.cxx:3837
 TClass.cxx:3838
 TClass.cxx:3839
 TClass.cxx:3840
 TClass.cxx:3841
 TClass.cxx:3842
 TClass.cxx:3843
 TClass.cxx:3844
 TClass.cxx:3845
 TClass.cxx:3846
 TClass.cxx:3847
 TClass.cxx:3848
 TClass.cxx:3849
 TClass.cxx:3850
 TClass.cxx:3851
 TClass.cxx:3852
 TClass.cxx:3853
 TClass.cxx:3854
 TClass.cxx:3855
 TClass.cxx:3856
 TClass.cxx:3857
 TClass.cxx:3858
 TClass.cxx:3859
 TClass.cxx:3860
 TClass.cxx:3861
 TClass.cxx:3862
 TClass.cxx:3863
 TClass.cxx:3864
 TClass.cxx:3865
 TClass.cxx:3866
 TClass.cxx:3867
 TClass.cxx:3868
 TClass.cxx:3869
 TClass.cxx:3870
 TClass.cxx:3871
 TClass.cxx:3872
 TClass.cxx:3873
 TClass.cxx:3874
 TClass.cxx:3875
 TClass.cxx:3876
 TClass.cxx:3877
 TClass.cxx:3878
 TClass.cxx:3879
 TClass.cxx:3880
 TClass.cxx:3881
 TClass.cxx:3882
 TClass.cxx:3883
 TClass.cxx:3884
 TClass.cxx:3885
 TClass.cxx:3886
 TClass.cxx:3887
 TClass.cxx:3888
 TClass.cxx:3889
 TClass.cxx:3890
 TClass.cxx:3891
 TClass.cxx:3892
 TClass.cxx:3893
 TClass.cxx:3894
 TClass.cxx:3895
 TClass.cxx:3896
 TClass.cxx:3897
 TClass.cxx:3898
 TClass.cxx:3899
 TClass.cxx:3900
 TClass.cxx:3901
 TClass.cxx:3902
 TClass.cxx:3903
 TClass.cxx:3904
 TClass.cxx:3905
 TClass.cxx:3906
 TClass.cxx:3907
 TClass.cxx:3908
 TClass.cxx:3909
 TClass.cxx:3910
 TClass.cxx:3911
 TClass.cxx:3912
 TClass.cxx:3913
 TClass.cxx:3914
 TClass.cxx:3915
 TClass.cxx:3916
 TClass.cxx:3917
 TClass.cxx:3918
 TClass.cxx:3919
 TClass.cxx:3920
 TClass.cxx:3921
 TClass.cxx:3922
 TClass.cxx:3923
 TClass.cxx:3924
 TClass.cxx:3925
 TClass.cxx:3926
 TClass.cxx:3927
 TClass.cxx:3928
 TClass.cxx:3929
 TClass.cxx:3930
 TClass.cxx:3931
 TClass.cxx:3932
 TClass.cxx:3933
 TClass.cxx:3934
 TClass.cxx:3935
 TClass.cxx:3936
 TClass.cxx:3937
 TClass.cxx:3938
 TClass.cxx:3939
 TClass.cxx:3940
 TClass.cxx:3941
 TClass.cxx:3942
 TClass.cxx:3943
 TClass.cxx:3944
 TClass.cxx:3945
 TClass.cxx:3946
 TClass.cxx:3947
 TClass.cxx:3948
 TClass.cxx:3949
 TClass.cxx:3950
 TClass.cxx:3951
 TClass.cxx:3952
 TClass.cxx:3953
 TClass.cxx:3954
 TClass.cxx:3955
 TClass.cxx:3956
 TClass.cxx:3957
 TClass.cxx:3958
 TClass.cxx:3959
 TClass.cxx:3960
 TClass.cxx:3961
 TClass.cxx:3962
 TClass.cxx:3963
 TClass.cxx:3964
 TClass.cxx:3965
 TClass.cxx:3966
 TClass.cxx:3967
 TClass.cxx:3968
 TClass.cxx:3969
 TClass.cxx:3970
 TClass.cxx:3971
 TClass.cxx:3972
 TClass.cxx:3973
 TClass.cxx:3974
 TClass.cxx:3975
 TClass.cxx:3976
 TClass.cxx:3977
 TClass.cxx:3978
 TClass.cxx:3979
 TClass.cxx:3980
 TClass.cxx:3981
 TClass.cxx:3982
 TClass.cxx:3983
 TClass.cxx:3984
 TClass.cxx:3985
 TClass.cxx:3986
 TClass.cxx:3987
 TClass.cxx:3988
 TClass.cxx:3989
 TClass.cxx:3990
 TClass.cxx:3991
 TClass.cxx:3992
 TClass.cxx:3993
 TClass.cxx:3994
 TClass.cxx:3995
 TClass.cxx:3996
 TClass.cxx:3997
 TClass.cxx:3998
 TClass.cxx:3999
 TClass.cxx:4000
 TClass.cxx:4001
 TClass.cxx:4002
 TClass.cxx:4003
 TClass.cxx:4004
 TClass.cxx:4005
 TClass.cxx:4006
 TClass.cxx:4007
 TClass.cxx:4008
 TClass.cxx:4009
 TClass.cxx:4010
 TClass.cxx:4011
 TClass.cxx:4012
 TClass.cxx:4013
 TClass.cxx:4014
 TClass.cxx:4015
 TClass.cxx:4016
 TClass.cxx:4017
 TClass.cxx:4018
 TClass.cxx:4019
 TClass.cxx:4020
 TClass.cxx:4021
 TClass.cxx:4022
 TClass.cxx:4023
 TClass.cxx:4024
 TClass.cxx:4025
 TClass.cxx:4026
 TClass.cxx:4027
 TClass.cxx:4028
 TClass.cxx:4029
 TClass.cxx:4030
 TClass.cxx:4031
 TClass.cxx:4032
 TClass.cxx:4033
 TClass.cxx:4034
 TClass.cxx:4035
 TClass.cxx:4036
 TClass.cxx:4037
 TClass.cxx:4038
 TClass.cxx:4039
 TClass.cxx:4040
 TClass.cxx:4041
 TClass.cxx:4042
 TClass.cxx:4043
 TClass.cxx:4044
 TClass.cxx:4045
 TClass.cxx:4046
 TClass.cxx:4047
 TClass.cxx:4048
 TClass.cxx:4049
 TClass.cxx:4050
 TClass.cxx:4051
 TClass.cxx:4052
 TClass.cxx:4053
 TClass.cxx:4054
 TClass.cxx:4055
 TClass.cxx:4056
 TClass.cxx:4057
 TClass.cxx:4058
 TClass.cxx:4059
 TClass.cxx:4060
 TClass.cxx:4061
 TClass.cxx:4062
 TClass.cxx:4063
 TClass.cxx:4064
 TClass.cxx:4065
 TClass.cxx:4066
 TClass.cxx:4067
 TClass.cxx:4068
 TClass.cxx:4069
 TClass.cxx:4070
 TClass.cxx:4071
 TClass.cxx:4072
 TClass.cxx:4073
 TClass.cxx:4074
 TClass.cxx:4075
 TClass.cxx:4076
 TClass.cxx:4077
 TClass.cxx:4078
 TClass.cxx:4079
 TClass.cxx:4080
 TClass.cxx:4081
 TClass.cxx:4082
 TClass.cxx:4083
 TClass.cxx:4084
 TClass.cxx:4085
 TClass.cxx:4086
 TClass.cxx:4087
 TClass.cxx:4088
 TClass.cxx:4089
 TClass.cxx:4090
 TClass.cxx:4091
 TClass.cxx:4092
 TClass.cxx:4093
 TClass.cxx:4094
 TClass.cxx:4095
 TClass.cxx:4096
 TClass.cxx:4097
 TClass.cxx:4098
 TClass.cxx:4099
 TClass.cxx:4100
 TClass.cxx:4101
 TClass.cxx:4102
 TClass.cxx:4103
 TClass.cxx:4104
 TClass.cxx:4105
 TClass.cxx:4106
 TClass.cxx:4107
 TClass.cxx:4108
 TClass.cxx:4109
 TClass.cxx:4110
 TClass.cxx:4111
 TClass.cxx:4112
 TClass.cxx:4113
 TClass.cxx:4114
 TClass.cxx:4115
 TClass.cxx:4116
 TClass.cxx:4117
 TClass.cxx:4118
 TClass.cxx:4119
 TClass.cxx:4120
 TClass.cxx:4121
 TClass.cxx:4122
 TClass.cxx:4123
 TClass.cxx:4124
 TClass.cxx:4125
 TClass.cxx:4126
 TClass.cxx:4127
 TClass.cxx:4128
 TClass.cxx:4129
 TClass.cxx:4130
 TClass.cxx:4131
 TClass.cxx:4132
 TClass.cxx:4133
 TClass.cxx:4134
 TClass.cxx:4135
 TClass.cxx:4136
 TClass.cxx:4137
 TClass.cxx:4138
 TClass.cxx:4139
 TClass.cxx:4140
 TClass.cxx:4141
 TClass.cxx:4142
 TClass.cxx:4143
 TClass.cxx:4144
 TClass.cxx:4145
 TClass.cxx:4146
 TClass.cxx:4147
 TClass.cxx:4148
 TClass.cxx:4149
 TClass.cxx:4150
 TClass.cxx:4151
 TClass.cxx:4152
 TClass.cxx:4153
 TClass.cxx:4154
 TClass.cxx:4155
 TClass.cxx:4156
 TClass.cxx:4157
 TClass.cxx:4158
 TClass.cxx:4159
 TClass.cxx:4160
 TClass.cxx:4161
 TClass.cxx:4162
 TClass.cxx:4163
 TClass.cxx:4164
 TClass.cxx:4165
 TClass.cxx:4166
 TClass.cxx:4167
 TClass.cxx:4168
 TClass.cxx:4169
 TClass.cxx:4170
 TClass.cxx:4171
 TClass.cxx:4172
 TClass.cxx:4173
 TClass.cxx:4174
 TClass.cxx:4175
 TClass.cxx:4176
 TClass.cxx:4177
 TClass.cxx:4178
 TClass.cxx:4179
 TClass.cxx:4180
 TClass.cxx:4181
 TClass.cxx:4182
 TClass.cxx:4183
 TClass.cxx:4184
 TClass.cxx:4185
 TClass.cxx:4186
 TClass.cxx:4187
 TClass.cxx:4188
 TClass.cxx:4189
 TClass.cxx:4190
 TClass.cxx:4191
 TClass.cxx:4192
 TClass.cxx:4193
 TClass.cxx:4194
 TClass.cxx:4195
 TClass.cxx:4196
 TClass.cxx:4197
 TClass.cxx:4198
 TClass.cxx:4199
 TClass.cxx:4200
 TClass.cxx:4201
 TClass.cxx:4202
 TClass.cxx:4203
 TClass.cxx:4204
 TClass.cxx:4205
 TClass.cxx:4206
 TClass.cxx:4207
 TClass.cxx:4208
 TClass.cxx:4209
 TClass.cxx:4210
 TClass.cxx:4211
 TClass.cxx:4212
 TClass.cxx:4213
 TClass.cxx:4214
 TClass.cxx:4215
 TClass.cxx:4216
 TClass.cxx:4217
 TClass.cxx:4218
 TClass.cxx:4219
 TClass.cxx:4220
 TClass.cxx:4221
 TClass.cxx:4222
 TClass.cxx:4223
 TClass.cxx:4224
 TClass.cxx:4225
 TClass.cxx:4226
 TClass.cxx:4227
 TClass.cxx:4228
 TClass.cxx:4229
 TClass.cxx:4230
 TClass.cxx:4231
 TClass.cxx:4232
 TClass.cxx:4233
 TClass.cxx:4234
 TClass.cxx:4235
 TClass.cxx:4236
 TClass.cxx:4237
 TClass.cxx:4238
 TClass.cxx:4239
 TClass.cxx:4240
 TClass.cxx:4241
 TClass.cxx:4242
 TClass.cxx:4243
 TClass.cxx:4244
 TClass.cxx:4245
 TClass.cxx:4246
 TClass.cxx:4247
 TClass.cxx:4248
 TClass.cxx:4249
 TClass.cxx:4250
 TClass.cxx:4251
 TClass.cxx:4252
 TClass.cxx:4253
 TClass.cxx:4254
 TClass.cxx:4255
 TClass.cxx:4256
 TClass.cxx:4257
 TClass.cxx:4258
 TClass.cxx:4259
 TClass.cxx:4260
 TClass.cxx:4261
 TClass.cxx:4262
 TClass.cxx:4263
 TClass.cxx:4264
 TClass.cxx:4265
 TClass.cxx:4266
 TClass.cxx:4267
 TClass.cxx:4268
 TClass.cxx:4269
 TClass.cxx:4270
 TClass.cxx:4271
 TClass.cxx:4272
 TClass.cxx:4273
 TClass.cxx:4274
 TClass.cxx:4275
 TClass.cxx:4276
 TClass.cxx:4277
 TClass.cxx:4278
 TClass.cxx:4279
 TClass.cxx:4280
 TClass.cxx:4281
 TClass.cxx:4282
 TClass.cxx:4283
 TClass.cxx:4284
 TClass.cxx:4285
 TClass.cxx:4286
 TClass.cxx:4287
 TClass.cxx:4288
 TClass.cxx:4289
 TClass.cxx:4290
 TClass.cxx:4291
 TClass.cxx:4292
 TClass.cxx:4293
 TClass.cxx:4294
 TClass.cxx:4295
 TClass.cxx:4296
 TClass.cxx:4297
 TClass.cxx:4298
 TClass.cxx:4299
 TClass.cxx:4300
 TClass.cxx:4301
 TClass.cxx:4302
 TClass.cxx:4303
 TClass.cxx:4304
 TClass.cxx:4305
 TClass.cxx:4306
 TClass.cxx:4307
 TClass.cxx:4308
 TClass.cxx:4309
 TClass.cxx:4310
 TClass.cxx:4311
 TClass.cxx:4312
 TClass.cxx:4313
 TClass.cxx:4314
 TClass.cxx:4315
 TClass.cxx:4316
 TClass.cxx:4317
 TClass.cxx:4318
 TClass.cxx:4319
 TClass.cxx:4320
 TClass.cxx:4321
 TClass.cxx:4322
 TClass.cxx:4323
 TClass.cxx:4324
 TClass.cxx:4325
 TClass.cxx:4326
 TClass.cxx:4327
 TClass.cxx:4328
 TClass.cxx:4329
 TClass.cxx:4330
 TClass.cxx:4331
 TClass.cxx:4332
 TClass.cxx:4333
 TClass.cxx:4334
 TClass.cxx:4335
 TClass.cxx:4336
 TClass.cxx:4337
 TClass.cxx:4338
 TClass.cxx:4339
 TClass.cxx:4340
 TClass.cxx:4341
 TClass.cxx:4342
 TClass.cxx:4343
 TClass.cxx:4344
 TClass.cxx:4345
 TClass.cxx:4346
 TClass.cxx:4347
 TClass.cxx:4348
 TClass.cxx:4349
 TClass.cxx:4350
 TClass.cxx:4351
 TClass.cxx:4352
 TClass.cxx:4353
 TClass.cxx:4354
 TClass.cxx:4355
 TClass.cxx:4356
 TClass.cxx:4357
 TClass.cxx:4358
 TClass.cxx:4359
 TClass.cxx:4360
 TClass.cxx:4361
 TClass.cxx:4362
 TClass.cxx:4363
 TClass.cxx:4364
 TClass.cxx:4365
 TClass.cxx:4366
 TClass.cxx:4367
 TClass.cxx:4368
 TClass.cxx:4369
 TClass.cxx:4370
 TClass.cxx:4371
 TClass.cxx:4372
 TClass.cxx:4373
 TClass.cxx:4374
 TClass.cxx:4375
 TClass.cxx:4376
 TClass.cxx:4377
 TClass.cxx:4378
 TClass.cxx:4379
 TClass.cxx:4380
 TClass.cxx:4381
 TClass.cxx:4382
 TClass.cxx:4383
 TClass.cxx:4384
 TClass.cxx:4385
 TClass.cxx:4386
 TClass.cxx:4387
 TClass.cxx:4388
 TClass.cxx:4389
 TClass.cxx:4390
 TClass.cxx:4391
 TClass.cxx:4392
 TClass.cxx:4393
 TClass.cxx:4394
 TClass.cxx:4395
 TClass.cxx:4396
 TClass.cxx:4397
 TClass.cxx:4398
 TClass.cxx:4399
 TClass.cxx:4400
 TClass.cxx:4401
 TClass.cxx:4402
 TClass.cxx:4403
 TClass.cxx:4404
 TClass.cxx:4405
 TClass.cxx:4406
 TClass.cxx:4407
 TClass.cxx:4408
 TClass.cxx:4409
 TClass.cxx:4410
 TClass.cxx:4411
 TClass.cxx:4412
 TClass.cxx:4413
 TClass.cxx:4414
 TClass.cxx:4415
 TClass.cxx:4416
 TClass.cxx:4417
 TClass.cxx:4418
 TClass.cxx:4419
 TClass.cxx:4420
 TClass.cxx:4421
 TClass.cxx:4422
 TClass.cxx:4423
 TClass.cxx:4424
 TClass.cxx:4425
 TClass.cxx:4426
 TClass.cxx:4427
 TClass.cxx:4428
 TClass.cxx:4429
 TClass.cxx:4430
 TClass.cxx:4431
 TClass.cxx:4432
 TClass.cxx:4433
 TClass.cxx:4434
 TClass.cxx:4435
 TClass.cxx:4436
 TClass.cxx:4437
 TClass.cxx:4438
 TClass.cxx:4439
 TClass.cxx:4440
 TClass.cxx:4441
 TClass.cxx:4442
 TClass.cxx:4443
 TClass.cxx:4444
 TClass.cxx:4445
 TClass.cxx:4446
 TClass.cxx:4447
 TClass.cxx:4448
 TClass.cxx:4449
 TClass.cxx:4450
 TClass.cxx:4451
 TClass.cxx:4452
 TClass.cxx:4453
 TClass.cxx:4454
 TClass.cxx:4455
 TClass.cxx:4456
 TClass.cxx:4457
 TClass.cxx:4458
 TClass.cxx:4459
 TClass.cxx:4460
 TClass.cxx:4461
 TClass.cxx:4462
 TClass.cxx:4463
 TClass.cxx:4464
 TClass.cxx:4465
 TClass.cxx:4466
 TClass.cxx:4467
 TClass.cxx:4468
 TClass.cxx:4469
 TClass.cxx:4470
 TClass.cxx:4471
 TClass.cxx:4472
 TClass.cxx:4473
 TClass.cxx:4474
 TClass.cxx:4475
 TClass.cxx:4476
 TClass.cxx:4477
 TClass.cxx:4478
 TClass.cxx:4479
 TClass.cxx:4480
 TClass.cxx:4481
 TClass.cxx:4482
 TClass.cxx:4483
 TClass.cxx:4484
 TClass.cxx:4485
 TClass.cxx:4486
 TClass.cxx:4487
 TClass.cxx:4488
 TClass.cxx:4489
 TClass.cxx:4490
 TClass.cxx:4491
 TClass.cxx:4492
 TClass.cxx:4493
 TClass.cxx:4494
 TClass.cxx:4495
 TClass.cxx:4496
 TClass.cxx:4497
 TClass.cxx:4498
 TClass.cxx:4499
 TClass.cxx:4500
 TClass.cxx:4501
 TClass.cxx:4502
 TClass.cxx:4503
 TClass.cxx:4504
 TClass.cxx:4505
 TClass.cxx:4506
 TClass.cxx:4507
 TClass.cxx:4508
 TClass.cxx:4509
 TClass.cxx:4510
 TClass.cxx:4511
 TClass.cxx:4512
 TClass.cxx:4513
 TClass.cxx:4514
 TClass.cxx:4515
 TClass.cxx:4516
 TClass.cxx:4517
 TClass.cxx:4518
 TClass.cxx:4519
 TClass.cxx:4520
 TClass.cxx:4521
 TClass.cxx:4522
 TClass.cxx:4523
 TClass.cxx:4524
 TClass.cxx:4525
 TClass.cxx:4526
 TClass.cxx:4527
 TClass.cxx:4528
 TClass.cxx:4529
 TClass.cxx:4530
 TClass.cxx:4531
 TClass.cxx:4532
 TClass.cxx:4533
 TClass.cxx:4534
 TClass.cxx:4535
 TClass.cxx:4536
 TClass.cxx:4537
 TClass.cxx:4538
 TClass.cxx:4539
 TClass.cxx:4540
 TClass.cxx:4541
 TClass.cxx:4542
 TClass.cxx:4543
 TClass.cxx:4544
 TClass.cxx:4545
 TClass.cxx:4546
 TClass.cxx:4547
 TClass.cxx:4548
 TClass.cxx:4549
 TClass.cxx:4550
 TClass.cxx:4551
 TClass.cxx:4552
 TClass.cxx:4553
 TClass.cxx:4554
 TClass.cxx:4555
 TClass.cxx:4556
 TClass.cxx:4557
 TClass.cxx:4558
 TClass.cxx:4559
 TClass.cxx:4560
 TClass.cxx:4561
 TClass.cxx:4562
 TClass.cxx:4563
 TClass.cxx:4564
 TClass.cxx:4565
 TClass.cxx:4566
 TClass.cxx:4567
 TClass.cxx:4568
 TClass.cxx:4569
 TClass.cxx:4570
 TClass.cxx:4571
 TClass.cxx:4572
 TClass.cxx:4573
 TClass.cxx:4574
 TClass.cxx:4575
 TClass.cxx:4576
 TClass.cxx:4577
 TClass.cxx:4578
 TClass.cxx:4579
 TClass.cxx:4580
 TClass.cxx:4581
 TClass.cxx:4582
 TClass.cxx:4583
 TClass.cxx:4584
 TClass.cxx:4585
 TClass.cxx:4586
 TClass.cxx:4587
 TClass.cxx:4588
 TClass.cxx:4589
 TClass.cxx:4590
 TClass.cxx:4591
 TClass.cxx:4592
 TClass.cxx:4593
 TClass.cxx:4594
 TClass.cxx:4595
 TClass.cxx:4596
 TClass.cxx:4597
 TClass.cxx:4598
 TClass.cxx:4599
 TClass.cxx:4600
 TClass.cxx:4601
 TClass.cxx:4602
 TClass.cxx:4603
 TClass.cxx:4604
 TClass.cxx:4605
 TClass.cxx:4606
 TClass.cxx:4607
 TClass.cxx:4608
 TClass.cxx:4609
 TClass.cxx:4610
 TClass.cxx:4611
 TClass.cxx:4612
 TClass.cxx:4613
 TClass.cxx:4614
 TClass.cxx:4615
 TClass.cxx:4616
 TClass.cxx:4617
 TClass.cxx:4618
 TClass.cxx:4619
 TClass.cxx:4620
 TClass.cxx:4621
 TClass.cxx:4622
 TClass.cxx:4623
 TClass.cxx:4624
 TClass.cxx:4625
 TClass.cxx:4626
 TClass.cxx:4627
 TClass.cxx:4628
 TClass.cxx:4629
 TClass.cxx:4630
 TClass.cxx:4631
 TClass.cxx:4632
 TClass.cxx:4633
 TClass.cxx:4634
 TClass.cxx:4635
 TClass.cxx:4636
 TClass.cxx:4637
 TClass.cxx:4638
 TClass.cxx:4639
 TClass.cxx:4640
 TClass.cxx:4641
 TClass.cxx:4642
 TClass.cxx:4643
 TClass.cxx:4644
 TClass.cxx:4645
 TClass.cxx:4646
 TClass.cxx:4647
 TClass.cxx:4648
 TClass.cxx:4649
 TClass.cxx:4650
 TClass.cxx:4651
 TClass.cxx:4652
 TClass.cxx:4653
 TClass.cxx:4654
 TClass.cxx:4655
 TClass.cxx:4656
 TClass.cxx:4657
 TClass.cxx:4658
 TClass.cxx:4659
 TClass.cxx:4660
 TClass.cxx:4661
 TClass.cxx:4662
 TClass.cxx:4663
 TClass.cxx:4664
 TClass.cxx:4665
 TClass.cxx:4666
 TClass.cxx:4667
 TClass.cxx:4668
 TClass.cxx:4669
 TClass.cxx:4670
 TClass.cxx:4671
 TClass.cxx:4672
 TClass.cxx:4673
 TClass.cxx:4674
 TClass.cxx:4675
 TClass.cxx:4676
 TClass.cxx:4677
 TClass.cxx:4678
 TClass.cxx:4679
 TClass.cxx:4680
 TClass.cxx:4681
 TClass.cxx:4682
 TClass.cxx:4683
 TClass.cxx:4684
 TClass.cxx:4685
 TClass.cxx:4686
 TClass.cxx:4687
 TClass.cxx:4688
 TClass.cxx:4689
 TClass.cxx:4690
 TClass.cxx:4691
 TClass.cxx:4692
 TClass.cxx:4693
 TClass.cxx:4694
 TClass.cxx:4695
 TClass.cxx:4696
 TClass.cxx:4697
 TClass.cxx:4698
 TClass.cxx:4699
 TClass.cxx:4700
 TClass.cxx:4701
 TClass.cxx:4702
 TClass.cxx:4703
 TClass.cxx:4704
 TClass.cxx:4705
 TClass.cxx:4706
 TClass.cxx:4707
 TClass.cxx:4708
 TClass.cxx:4709
 TClass.cxx:4710
 TClass.cxx:4711
 TClass.cxx:4712
 TClass.cxx:4713
 TClass.cxx:4714
 TClass.cxx:4715
 TClass.cxx:4716
 TClass.cxx:4717
 TClass.cxx:4718
 TClass.cxx:4719
 TClass.cxx:4720
 TClass.cxx:4721
 TClass.cxx:4722
 TClass.cxx:4723
 TClass.cxx:4724
 TClass.cxx:4725
 TClass.cxx:4726
 TClass.cxx:4727
 TClass.cxx:4728
 TClass.cxx:4729
 TClass.cxx:4730
 TClass.cxx:4731
 TClass.cxx:4732
 TClass.cxx:4733
 TClass.cxx:4734
 TClass.cxx:4735
 TClass.cxx:4736
 TClass.cxx:4737
 TClass.cxx:4738
 TClass.cxx:4739
 TClass.cxx:4740
 TClass.cxx:4741
 TClass.cxx:4742
 TClass.cxx:4743
 TClass.cxx:4744
 TClass.cxx:4745
 TClass.cxx:4746
 TClass.cxx:4747
 TClass.cxx:4748
 TClass.cxx:4749
 TClass.cxx:4750
 TClass.cxx:4751
 TClass.cxx:4752
 TClass.cxx:4753
 TClass.cxx:4754
 TClass.cxx:4755
 TClass.cxx:4756
 TClass.cxx:4757
 TClass.cxx:4758
 TClass.cxx:4759
 TClass.cxx:4760
 TClass.cxx:4761
 TClass.cxx:4762
 TClass.cxx:4763
 TClass.cxx:4764
 TClass.cxx:4765
 TClass.cxx:4766
 TClass.cxx:4767
 TClass.cxx:4768
 TClass.cxx:4769
 TClass.cxx:4770
 TClass.cxx:4771
 TClass.cxx:4772
 TClass.cxx:4773
 TClass.cxx:4774
 TClass.cxx:4775
 TClass.cxx:4776
 TClass.cxx:4777
 TClass.cxx:4778
 TClass.cxx:4779
 TClass.cxx:4780
 TClass.cxx:4781
 TClass.cxx:4782
 TClass.cxx:4783
 TClass.cxx:4784
 TClass.cxx:4785
 TClass.cxx:4786
 TClass.cxx:4787
 TClass.cxx:4788
 TClass.cxx:4789
 TClass.cxx:4790
 TClass.cxx:4791
 TClass.cxx:4792
 TClass.cxx:4793
 TClass.cxx:4794
 TClass.cxx:4795
 TClass.cxx:4796
 TClass.cxx:4797
 TClass.cxx:4798
 TClass.cxx:4799
 TClass.cxx:4800
 TClass.cxx:4801
 TClass.cxx:4802
 TClass.cxx:4803
 TClass.cxx:4804
 TClass.cxx:4805
 TClass.cxx:4806
 TClass.cxx:4807
 TClass.cxx:4808
 TClass.cxx:4809
 TClass.cxx:4810
 TClass.cxx:4811
 TClass.cxx:4812
 TClass.cxx:4813
 TClass.cxx:4814
 TClass.cxx:4815
 TClass.cxx:4816
 TClass.cxx:4817
 TClass.cxx:4818
 TClass.cxx:4819
 TClass.cxx:4820
 TClass.cxx:4821
 TClass.cxx:4822
 TClass.cxx:4823
 TClass.cxx:4824
 TClass.cxx:4825
 TClass.cxx:4826
 TClass.cxx:4827
 TClass.cxx:4828
 TClass.cxx:4829
 TClass.cxx:4830
 TClass.cxx:4831
 TClass.cxx:4832
 TClass.cxx:4833
 TClass.cxx:4834
 TClass.cxx:4835
 TClass.cxx:4836
 TClass.cxx:4837
 TClass.cxx:4838
 TClass.cxx:4839
 TClass.cxx:4840
 TClass.cxx:4841
 TClass.cxx:4842
 TClass.cxx:4843
 TClass.cxx:4844
 TClass.cxx:4845
 TClass.cxx:4846
 TClass.cxx:4847
 TClass.cxx:4848
 TClass.cxx:4849
 TClass.cxx:4850
 TClass.cxx:4851
 TClass.cxx:4852
 TClass.cxx:4853
 TClass.cxx:4854
 TClass.cxx:4855
 TClass.cxx:4856
 TClass.cxx:4857
 TClass.cxx:4858
 TClass.cxx:4859
 TClass.cxx:4860
 TClass.cxx:4861
 TClass.cxx:4862
 TClass.cxx:4863
 TClass.cxx:4864
 TClass.cxx:4865
 TClass.cxx:4866
 TClass.cxx:4867
 TClass.cxx:4868
 TClass.cxx:4869
 TClass.cxx:4870
 TClass.cxx:4871
 TClass.cxx:4872
 TClass.cxx:4873
 TClass.cxx:4874
 TClass.cxx:4875
 TClass.cxx:4876
 TClass.cxx:4877
 TClass.cxx:4878
 TClass.cxx:4879
 TClass.cxx:4880
 TClass.cxx:4881
 TClass.cxx:4882
 TClass.cxx:4883
 TClass.cxx:4884
 TClass.cxx:4885
 TClass.cxx:4886
 TClass.cxx:4887
 TClass.cxx:4888
 TClass.cxx:4889
 TClass.cxx:4890
 TClass.cxx:4891
 TClass.cxx:4892
 TClass.cxx:4893
 TClass.cxx:4894
 TClass.cxx:4895
 TClass.cxx:4896
 TClass.cxx:4897
 TClass.cxx:4898
 TClass.cxx:4899
 TClass.cxx:4900
 TClass.cxx:4901
 TClass.cxx:4902
 TClass.cxx:4903
 TClass.cxx:4904
 TClass.cxx:4905
 TClass.cxx:4906
 TClass.cxx:4907
 TClass.cxx:4908
 TClass.cxx:4909
 TClass.cxx:4910
 TClass.cxx:4911
 TClass.cxx:4912
 TClass.cxx:4913
 TClass.cxx:4914
 TClass.cxx:4915
 TClass.cxx:4916
 TClass.cxx:4917
 TClass.cxx:4918
 TClass.cxx:4919
 TClass.cxx:4920
 TClass.cxx:4921
 TClass.cxx:4922
 TClass.cxx:4923
 TClass.cxx:4924
 TClass.cxx:4925
 TClass.cxx:4926
 TClass.cxx:4927
 TClass.cxx:4928
 TClass.cxx:4929
 TClass.cxx:4930
 TClass.cxx:4931
 TClass.cxx:4932
 TClass.cxx:4933
 TClass.cxx:4934
 TClass.cxx:4935
 TClass.cxx:4936
 TClass.cxx:4937
 TClass.cxx:4938
 TClass.cxx:4939
 TClass.cxx:4940
 TClass.cxx:4941
 TClass.cxx:4942
 TClass.cxx:4943
 TClass.cxx:4944
 TClass.cxx:4945
 TClass.cxx:4946
 TClass.cxx:4947
 TClass.cxx:4948
 TClass.cxx:4949
 TClass.cxx:4950
 TClass.cxx:4951
 TClass.cxx:4952
 TClass.cxx:4953
 TClass.cxx:4954
 TClass.cxx:4955
 TClass.cxx:4956
 TClass.cxx:4957
 TClass.cxx:4958
 TClass.cxx:4959
 TClass.cxx:4960
 TClass.cxx:4961
 TClass.cxx:4962
 TClass.cxx:4963
 TClass.cxx:4964
 TClass.cxx:4965
 TClass.cxx:4966
 TClass.cxx:4967
 TClass.cxx:4968
 TClass.cxx:4969
 TClass.cxx:4970
 TClass.cxx:4971
 TClass.cxx:4972
 TClass.cxx:4973
 TClass.cxx:4974
 TClass.cxx:4975
 TClass.cxx:4976
 TClass.cxx:4977
 TClass.cxx:4978
 TClass.cxx:4979
 TClass.cxx:4980
 TClass.cxx:4981
 TClass.cxx:4982