// @(#)root/io:$Id$
// Author: Rene Brun   12/10/2000

/*************************************************************************
 * 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.             *
 *************************************************************************/


//////////////////////////////////////////////////////////////////////////
//                                                                      //
// A TStreamerInfo object describes a persistent version of a class.    //
// A ROOT file contains the list of TStreamerInfo objects for all the   //
// class versions written to this file.                                 //
// When reading a file, all the TStreamerInfo objects are read back in  //
// memory and registered to the TClass list of TStreamerInfo.           //
//                                                                      //
// One can see the list and contents of the TStreamerInfo on a file     //
// with, eg,                                                            //
//    TFile f("myfile.root");                                           //
//    f.ShowStreamerInfo();                                             //
//                                                                      //
// A TStreamerInfo is a list of TStreamerElement objects (one per data  //
// member or base class).                                               //
// When streaming an object, the system (TClass) loops on all the       //
// TStreamerElement objects and calls the appropriate function for each //
// element type.                                                        //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

#include "TStreamerInfo.h"
#include "TFile.h"
#include "TROOT.h"
#include "TClonesArray.h"
#include "TStreamerElement.h"
#include "TClass.h"
#include "TClassEdit.h"
#include "TDataMember.h"
#include "TMethodCall.h"
#include "TDataType.h"
#include "TRealData.h"
#include "TBaseClass.h"
#include "TBuffer.h"
#include "TArrayC.h"
#include "TArrayI.h"
#include "TArrayF.h"
#include "TArrayD.h"
#include "TArrayS.h"
#include "TArrayL.h"
#include "TError.h"
#include "TRef.h"
#include "TProcessID.h"
#include "TSystem.h"

#include "TStreamer.h"
#include "TContainerConverters.h"
#include "TCollectionProxyFactory.h"
#include "TVirtualCollectionProxy.h"
#include "TInterpreter.h"

#include "TMemberInspector.h"

#include "TMakeProject.h"

#include "TSchemaRuleSet.h"
#include "TSchemaRule.h"

#include "TVirtualMutex.h"

#include "TStreamerInfoActions.h"

std::atomic<Int_t>   TStreamerInfo::fgCount{0};

const Int_t kMaxLen = 1024;

ClassImp(TStreamerInfo)

static void R__TObjArray_InsertAt(TObjArray *arr, TObject *obj, Int_t at)
{
   // Slide by one.
   Int_t last = arr->GetLast();
   arr->AddAtAndExpand(arr->At(last),last+1);
   for(Int_t ind = last-1; ind >= at; --ind) {
      arr->AddAt( arr->At(ind), ind+1);
   };
   arr->AddAt( obj, at);
}

static void R__TObjArray_InsertAt(TObjArray *arr, std::vector<TStreamerArtificial*> &objs, Int_t at)
{
   // Slide by enough.
   Int_t offset = objs.size();
   Int_t last = arr->GetLast();
   arr->AddAtAndExpand(arr->At(last),last+offset);
   for(Int_t ind = last-1; ind >= at; --ind) {
      arr->AddAt( arr->At(ind), ind+offset);
   };
   for(size_t ins = 0; ins < objs.size(); ++ins) {
      arr->AddAt(objs[ins], at+ins);
   }
}

static void R__TObjArray_InsertAfter(TObjArray *arr, TObject *newobj, TObject *oldobj)
{
   // Slide by one.
   Int_t last = arr->GetLast();
   Int_t at = 0;
   while (at<last && arr->At(at) != oldobj) {
      ++at;
   }
   ++at; // we found the object, insert after it
   R__TObjArray_InsertAt(arr, newobj, at);
}

static void R__TObjArray_InsertBefore(TObjArray *arr, TObject *newobj, TObject *oldobj)
{
   // Slide by one.
   Int_t last = arr->GetLast();
   Int_t at = 0;
   while (at<last && arr->At(at) != oldobj) {
      ++at;
   }
   R__TObjArray_InsertAt(arr, newobj, at);
}

//______________________________________________________________________________
TStreamerInfo::TStreamerInfo()
{
   // Default ctor.

   fNumber   = fgCount;
   fClass    = 0;
   fElements = 0;
   fComp     = 0;
   fCompFull = 0;
   fCompOpt  = 0;
   fCheckSum = 0;
   fNdata    = 0;
   fNfulldata= 0;
   fNslots   = 0;
   fSize     = 0;
   fClassVersion = 0;
   fOnFileClassVersion = 0;
   fOldVersion = Class()->GetClassVersion();
   fNVirtualInfoLoc = 0;
   fVirtualInfoLoc = 0;
   fLiveCount = 0;

   fReadObjectWise = 0;
   fReadMemberWise = 0;
   fReadMemberWiseVecPtr = 0;
   fWriteObjectWise = 0;
   fWriteMemberWise = 0;
   fWriteMemberWiseVecPtr = 0;
}

//______________________________________________________________________________
TStreamerInfo::TStreamerInfo(TClass *cl)
: TVirtualStreamerInfo(cl)
{
   // Create a TStreamerInfo object.

   fgCount++;
   fNumber   = fgCount;
   fClass    = cl;
   fElements = new TObjArray();
   fComp     = 0;
   fCompFull = 0;
   fCompOpt  = 0;
   fCheckSum = 0;
   fNdata    = 0;
   fNfulldata= 0;
   fNslots   = 0;
   fSize     = 0;
   fClassVersion = fClass->GetClassVersion();
   fOnFileClassVersion = 0;
   fOldVersion = Class()->GetClassVersion();
   fNVirtualInfoLoc = 0;
   fVirtualInfoLoc = 0;
   fLiveCount = 0;

   fReadObjectWise = 0;
   fReadMemberWise = 0;
   fReadMemberWiseVecPtr = 0;
   fWriteObjectWise = 0;
   fWriteMemberWise = 0;
   fWriteMemberWiseVecPtr = 0;
}

//______________________________________________________________________________
TStreamerInfo::~TStreamerInfo()
{
   // TStreamerInfo dtor.

   delete [] fComp;     fComp     = 0;
   delete [] fCompFull; fCompFull = 0;
   delete [] fCompOpt;  fCompOpt  = 0;
   delete [] fVirtualInfoLoc; fVirtualInfoLoc =0;

   delete fReadObjectWise;
   delete fReadMemberWise;
   delete fReadMemberWiseVecPtr;
   delete fWriteObjectWise;
   delete fWriteMemberWise;
   delete fWriteMemberWiseVecPtr;

   if (!fElements) return;
   fElements->Delete();
   delete fElements; fElements=0;
}

//______________________________________________________________________________
namespace {
   // Makes sure kBuildOldUsed set once Build or BuildOld finishes
   // Makes sure kBuildRunning reset once Build finishes
   struct TPreventRecursiveBuildGuard {
      TPreventRecursiveBuildGuard(TStreamerInfo* info): fInfo(info) {
         fInfo->SetBit(TStreamerInfo::kBuildRunning);
         fInfo->SetBit(TStreamerInfo::kBuildOldUsed);
      }
      ~TPreventRecursiveBuildGuard() {
         fInfo->ResetBit(TStreamerInfo::kBuildOldUsed);
         fInfo->ResetBit(TStreamerInfo::kBuildRunning);
      }
      TStreamerInfo* fInfo;
   };

}

//______________________________________________________________________________
void TStreamerInfo::Build()
{
   // Build the I/O data structure for the current class version.
   // A list of TStreamerElement derived classes is built by scanning
   // one by one the list of data members of the analyzed class.

   // Did another thread already do the work?
   if (fIsCompiled) return;

   R__LOCKGUARD(gInterpreterMutex);

   // Did another thread already do the work while we were waiting ..
   if (fIsCompiled) return;

   // Has Build already been run?
   if (fIsBuilt) return;

   // Are we recursing on ourself?
   if (TestBit(TStreamerInfo::kBuildRunning)) return;

   // This is used to avoid unwanted recursive call to Build or BuildOld.
   TPreventRecursiveBuildGuard buildGuard(this);

   if (fClass->GetCollectionProxy()) {
      TVirtualCollectionProxy *proxy = fClass->GetCollectionProxy();
      TString title;
      if (proxy->GetValueClass()) {
         title.Form("<%s%s> Used to call the proper TStreamerInfo case",proxy->GetValueClass()->GetName(),proxy->HasPointers() ? "*" : "");
      } else {
         title .Form("<%s%s> Used to call the proper TStreamerInfo case",TDataType::GetTypeName(proxy->GetType()),proxy->HasPointers() ? "*" : "");
      }
      TStreamerElement* element = new TStreamerSTL("This", title.Data(), 0, fClass->GetName(), *proxy, 0);
      fElements->Add(element);
      Compile();
      fIsBuilt = kTRUE;
      return;
   }

   TStreamerElement::Class()->IgnoreTObjectStreamer();

   fClass->BuildRealData();

   fCheckSum = fClass->GetCheckSum();

   Bool_t needAllocClass = kFALSE;
   Bool_t wasCompiled = fComp != 0;
   const ROOT::TSchemaMatch* rules = 0;
   if (fClass->GetSchemaRules()) {
       rules = fClass->GetSchemaRules()->FindRules(fClass->GetName(), fClassVersion);
   }

   //
   // Iterate over base classes.
   //

   bool isCollection = fClass->GetCollectionProxy();
   bool isString = !strcmp(fClass->GetName(), "string");

   TBaseClass* base = 0;
   TIter nextb(fClass->GetListOfBases());
   while ((base = (TBaseClass*)nextb())) {
      TStreamerElement* element = 0;
      Int_t offset = base->GetDelta();
      if (offset == kMissing) {
         continue;
      }
      if (offset == kNeedObjectForVirtualBaseClass) {
         Error("Build()", "Cannot stream virtual base %s of class %s",
               base->GetName(), fClass->GetName());
         continue;
      }
      const char* bname  = base->GetName();
      const char* btitle = base->GetTitle();
      // this case appears with STL collections as base class.
      if (!strcmp(bname, "string")) {
         element = new TStreamerSTLstring(bname, btitle, offset, bname, kFALSE);
      } else if (base->IsSTLContainer()) {
         TVirtualCollectionProxy *proxy = base->GetClassPointer()->GetCollectionProxy();
         if (proxy) element = new TStreamerSTL(bname, btitle, offset, bname, *proxy, kFALSE);
         else       element = new TStreamerSTL(bname, btitle, offset, bname, 0, kFALSE);
         if (fClass->IsLoaded() && ((TStreamerSTL*)element)->GetSTLtype() != ROOT::kSTLvector) {
            if (!element->GetClassPointer()->IsLoaded()) {
               Error("Build","The class \"%s\" is compiled and its base class \"%s\" is a collection and we do not have a dictionary for it, we will not be able to read or write this base class.",GetName(),bname);
               delete element;
               continue;
            }
         }
      } else {
         element = new TStreamerBase(bname, btitle, offset);
         TClass* clm = element->GetClassPointer();
         if (!clm) {
            // We have no information about the class yet, except that since it
            // is a base class, we know it is a class.  So let's create it (in v5
            // it would have been created as a side effect of the dictionary of
            // for the derived class having a forward declaration of the base class).
            clm = new TClass(bname,1,TClass::kForwardDeclared, true /*silent*/);
            Warning("Build", "%s: base class %s has no streamer or dictionary it will not be saved", GetName(), clm->GetName());
            element->Init(0);
         } else {
            // Now part of the TStreamerBase constructor.
            // clm->GetStreamerInfo();
            if ((clm == TObject::Class()) && fClass->CanIgnoreTObjectStreamer()) {
               // -- An ignored TObject base class.
               // Note: The TClass kIgnoreTObjectStreamer == BIT(15), but
               // the TStreamerInfo kIgnoreTobjectStreamer == BIT(13) which
               // is confusing.
               SetBit(kIgnoreTObjectStreamer);
               // Flag the element to be ignored by setting its type to -1.
               // This flag will be used later by Compile() to prevent this
               // element from being inserted into the compiled info.
               element->SetType(-1);
            }
            if (!clm->IsLoaded() && !(isCollection || isString)) {
               // Don't complain about the base classes of collections nor of
               // std::string.
               Warning("Build", "%s: base class %s has no streamer or dictionary it will not be saved", GetName(), clm->GetName());
            }
         }
      }
      if (element) {
         fElements->Add(element);
      }
   } // end of base class loop

   //
   // Iterate over data members.
   //

   Int_t dsize;
   TDataMember* dm = 0;
   TIter nextd(fClass->GetListOfDataMembers());
   while ((dm = (TDataMember*) nextd())) {
      if (fClass->GetClassVersion() == 0) {
         continue;
      }
      if (!dm->IsPersistent()) {
         continue;
      }
      TMemberStreamer* streamer = 0;
      Int_t offset = GetDataMemberOffset(dm, streamer);
      if (offset == kMissing) {
         continue;
      }
      TStreamerElement* element = 0;
      dsize = 0;
      const char* dmName = dm->GetName();
      const char* dmTitle = dm->GetTitle();
      const char* dmType = dm->GetTypeName();
      const char* dmFull = dm->GetTrueTypeName(); // Used to be GetFullTypeName ...
      Bool_t dmIsPtr = dm->IsaPointer();
      TDataMember* dmCounter = 0;
      if (dmIsPtr) {
         //
         // look for a pointer data member with a counter
         // in the comment string, like so:
         //
         //      int n;
         //      double* MyArray; //[n]
         //
         const char* lbracket = TVirtualStreamerInfo::GetElementCounterStart(dmTitle);
         const char* rbracket = ::strchr(dmTitle, ']');
         if (lbracket && rbracket) {
            const char* counterName = dm->GetArrayIndex();
            TRealData* rdCounter = (TRealData*) fClass->GetListOfRealData()->FindObject(counterName);
            if (!rdCounter || rdCounter->TestBit(TRealData::kTransient)) {
               Error("Build", "%s, discarding: %s %s, illegal %s\n", GetName(), dmFull, dmName, dmTitle);
               continue;
            }
            dmCounter = rdCounter->GetDataMember();
            TDataType* dtCounter = dmCounter->GetDataType();
            Bool_t isInteger = dtCounter && ((dtCounter->GetType() == 3) || (dtCounter->GetType() == 13));
            if (!dtCounter || !isInteger) {
               Error("Build", "%s, discarding: %s %s, illegal [%s] (must be Int_t)\n", GetName(), dmFull, dmName, counterName);
               continue;
            }
            TStreamerBasicType* bt = TStreamerInfo::GetElementCounter(counterName, dmCounter->GetClass());
            if (!bt) {
               if (dmCounter->GetClass()->Property() & kIsAbstract) {
                  continue;
               }
               Error("Build", "%s, discarding: %s %s, illegal [%s] must be placed before \n", GetName(), dmFull, dmName, counterName);
               continue;
            }
         }
      }
      TDataType* dt = dm->GetDataType();
      if (dt) {
         // found a basic type
         Int_t dtype = dt->GetType();
         dsize = dt->Size();
         if (!dmCounter && (strstr(dmFull, "char*") || strstr(dmFull, "Char_t*"))) {
            dtype = kCharStar;
            dsize = sizeof(char*);
         }
         if (dtype == kOther_t || dtype == kNoType_t) {
            Error("Build", "%s, unknown type: %s %s", GetName(), dmFull, dmName);
            continue;
         } else if (dmIsPtr && (dtype != kCharStar)) {
            if (dmCounter) {
               // data member is pointer to an array of basic types
               element = new TStreamerBasicPointer(dmName, dmTitle, offset, dtype, dm->GetArrayIndex(), dmCounter->GetClass()->GetName(), dmCounter->GetClass()->GetClassVersion(), dmFull);
            } else {
               if ((fName == "TString") || (fName == "TClass")) {
                  continue;
               }
               Error("Build", "%s, discarding: %s %s, no [dimension]\n", GetName(), dmFull, dmName);
               continue;
            }
         } else {
            // data member is a basic type
            if ((fClass == TObject::Class()) && !strcmp(dmName, "fBits")) {
               //printf("found fBits, changing dtype from %d to 15\n", dtype);
               dtype = kBits;
            }
            element = new TStreamerBasicType(dmName, dmTitle, offset, dtype, dmFull);
         }
      } else {
         // try STL container or string
         static const char* full_string_name = "basic_string<char,char_traits<char>,allocator<char> >";
         if (!strcmp(dmType, "string") || !strcmp(dmType, "std::string") || !strcmp(dmType, full_string_name)) {
            element = new TStreamerSTLstring(dmName, dmTitle, offset, dmFull, dmIsPtr);
         } else if (dm->IsSTLContainer()) {
            TVirtualCollectionProxy *proxy = TClass::GetClass(dm->GetTypeName() /* the underlying type */)->GetCollectionProxy();
            if (proxy) element = new TStreamerSTL(dmName, dmTitle, offset, dmFull, *proxy, dmIsPtr);
            else element = new TStreamerSTL(dmName, dmTitle, offset, dmFull, dm->GetTrueTypeName(), dmIsPtr);
            if (((TStreamerSTL*)element)->GetSTLtype() != ROOT::kSTLvector) {
               if (fClass->IsLoaded()) {
                  if (!element->GetClassPointer()->IsLoaded()) {
                     Error("Build","The class \"%s\" is compiled and for its the data member \"%s\", we do not have a dictionary for the collection \"%s\", we will not be able to read or write this data member.",GetName(),dmName,element->GetClassPointer()->GetName());
                     delete element;
                     continue;
                  }
               } else if (fClass->GetState() == TClass::kInterpreted) {
                  if (element->GetClassPointer()->GetCollectionProxy()->GetProperties() & TVirtualCollectionProxy::kIsEmulated) {
                     Error("Build","The class \"%s\" is interpreted and for its the data member \"%s\", we do not have a dictionary for the collection \"%s\", we will not be able to read or write this data member.",GetName(),dmName,element->GetClassPointer()->GetName());
                     delete element;
                     continue;
                  }
               }
            }
         } else {
            TClass* clm = TClass::GetClass(dmType);
            if (!clm) {
               Error("Build", "%s, unknown type: %s %s\n", GetName(), dmFull, dmName);
               continue;
            }
            if (dmIsPtr) {
               // a pointer to a class
               if (dmCounter) {
                  element = new TStreamerLoop(dmName, dmTitle, offset, dm->GetArrayIndex(), dmCounter->GetClass()->GetName(), dmCounter->GetClass()->GetClassVersion(), dmFull);
               } else {
                  if (clm->IsTObject()) {
                     element = new TStreamerObjectPointer(dmName, dmTitle, offset, dmFull);
                  } else {
                     element = new TStreamerObjectAnyPointer(dmName, dmTitle, offset, dmFull);
                     if (!streamer && !clm->GetStreamer() && !clm->IsLoaded()) {
                        Error("Build", "%s: %s has no streamer or dictionary, data member %s will not be saved", GetName(), dmFull, dmName);
                     }
                  }
               }
            } else if (clm->IsTObject()) {
               element = new TStreamerObject(dmName, dmTitle, offset, dmFull);
            } else if ((clm == TString::Class()) && !dmIsPtr) {
               element = new TStreamerString(dmName, dmTitle, offset);
            } else {
               element = new TStreamerObjectAny(dmName, dmTitle, offset, dmFull);
               if (!streamer && !clm->GetStreamer() && !clm->IsLoaded()) {
                  Warning("Build", "%s: %s has no streamer or dictionary, data member \"%s\" will not be saved", GetName(), dmFull, dmName);
               }
            }
         }
      }
      if (!element) {
         // If we didn't make an element, there is nothing to do.
         continue;
      }
      Int_t ndim = dm->GetArrayDim();
      if (!dsize) {
         dsize = dm->GetUnitSize();
      }
      for (Int_t i = 0; i < ndim; ++i) {
         element->SetMaxIndex(i, dm->GetMaxIndex(i));
      }
      element->SetArrayDim(ndim);
      Int_t narr = element->GetArrayLength();
      if (!narr) {
         narr = 1;
      }
      element->SetSize(dsize*narr);
      element->SetStreamer(streamer);
      if (!streamer) {
         Int_t k = element->GetType();
         if (k == kStreamer) {
            //if ((k == kSTL) || (k == kSTL + kOffsetL) || (k == kStreamer) || (k == kStreamLoop))
            element->SetType(-1);
         }
      }

      if ( !wasCompiled && (rules && rules->HasRuleWithSource( element->GetName(), kTRUE )) ) {
         needAllocClass = kTRUE;

         // If this is optimized to re-use TStreamerElement(s) in case of variable renaming,
         // then we must revisit the code in TBranchElement::InitInfo that recalculate the
         // fID (i.e. the index of the TStreamerElement to be used for streaming).

         TStreamerElement *cached = element;
         // Now that we are caching the unconverted element, we do not assign it to the real type even if we could have!
         if (element->GetNewType()>0 /* intentionally not including base class for now */
             && rules && !rules->HasRuleWithTarget( element->GetName(), kTRUE ) )
         {
            TStreamerElement *copy = (TStreamerElement*)element->Clone();
            fElements->Add(copy);
            copy->SetBit(TStreamerElement::kRepeat);
            cached = copy;

            // Warning("BuildOld","%s::%s is not set from the version %d of %s (You must add a rule for it)\n",GetName(), element->GetName(), GetClassVersion(), GetName() );
         } else {
            // If the element is just cached and not repeat, we need to inject an element
            // to insure the writing.
            TStreamerElement *writecopy = (TStreamerElement*)element->Clone();
            fElements->Add(element);
            writecopy->SetBit(TStreamerElement::kWrite);
            writecopy->SetNewType( writecopy->GetType() );
            // Put the write element after the read element (that does caching).
            element = writecopy;
         }
         cached->SetBit(TStreamerElement::kCache);
         cached->SetNewType( cached->GetType() );
      }

      fElements->Add(element);
   } // end of member loop

   // Now add artificial TStreamerElement (i.e. rules that creates new members or set transient members).
   InsertArtificialElements(rules);

   if (needAllocClass) {
      TStreamerInfo *infoalloc  = (TStreamerInfo *)Clone(TString::Format("%s@@%d",GetName(),GetClassVersion()));
      if (!infoalloc) {
         Error("Build","Could you create a TStreamerInfo for %s\n",TString::Format("%s@@%d",GetName(),GetClassVersion()).Data());
      } else {
         // Tell clone we should rerun BuildOld
         infoalloc->SetBit(kBuildOldUsed,false);
         infoalloc->BuildCheck();
         infoalloc->BuildOld();
         TClass *allocClass = infoalloc->GetClass();

         {
            TIter next(fElements);
            TStreamerElement* element;
            while ((element = (TStreamerElement*) next())) {
               if (element->TestBit(TStreamerElement::kRepeat) && element->IsaPointer()) {
                  TStreamerElement *other = (TStreamerElement*) infoalloc->GetElements()->FindObject(element->GetName());
                  if (other) {
                     other->SetBit(TStreamerElement::kDoNotDelete);
                  }
               }
            }
            infoalloc->GetElements()->Compress();
         }
         {
            TIter next(fElements);
            TStreamerElement* element;
            while ((element = (TStreamerElement*) next())) {
            if (element->TestBit(TStreamerElement::kCache)) {
               element->SetOffset(infoalloc->GetOffset(element->GetName()));
            }
            }
         }

         TStreamerElement *el = new TStreamerArtificial("@@alloc","", 0, TStreamerInfo::kCacheNew, allocClass->GetName());
         R__TObjArray_InsertAt( fElements, el, 0 );

         el = new TStreamerArtificial("@@dealloc","", 0, TStreamerInfo::kCacheDelete, allocClass->GetName());
         fElements->Add( el );
      }
   }

   //
   // Make a more compact version.
   //
   Compile();
   fIsBuilt = kTRUE;
}

//______________________________________________________________________________
void TStreamerInfo::BuildCheck(TFile *file /* = 0 */)
{
   // Check if built and consistent with the class dictionary.
   // This method is called by TFile::ReadStreamerInfo.

   R__LOCKGUARD(gInterpreterMutex);

   fClass = TClass::GetClass(GetName());
   if (!fClass) {
      // fClassVersion should have been a Version_t and/or Version_t
      // should have been an Int_t.  Changing the on-file format
      // of the StreamerInfo is 'hard' (for forward compatibility), so
      // leave it as is for now.
      fClass = new TClass(GetName(), (Version_t)fClassVersion);
      fClass->SetBit(TClass::kIsEmulation);

      // Case of a custom collection (the user provided a CollectionProxy
      // for a class that is not an STL collection).
      if (GetElements()->GetEntries() == 1) {
         TObject *element = GetElements()->UncheckedAt(0);
         Bool_t isstl = element && strcmp("This",element->GetName())==0;
         if (isstl) {
            if (element->GetTitle()[0] == '<') {
               // We know the content.
               TString content = element->GetTitle();
               Int_t level = 1;
               for(Int_t c = 1; c < content.Length(); ++c) {
                  if (content[c] == '<') ++level;
                  else if (content[c] == '>') --level;
                  if (level == 0) {
                     content.Remove(c+1);
                     break;
                  }
               }
               content.Prepend("vector");
               TClass *clequiv = TClass::GetClass(content);
               TVirtualCollectionProxy *proxy = clequiv->GetCollectionProxy();
               if (gDebug > 1)
                  Info("BuildCheck",
                       "Update the collection proxy of the class \"%s\" \n"
                       "\tto be similar to \"%s\".",
                    GetName(),content.Data());
               fClass->CopyCollectionProxy( *proxy );
            } else {
               Warning("BuildCheck", "\n\
   The class %s had a collection proxy when written but it is not an STL\n \
   collection and we did not record the type of the content of the collection.\n \
   We will claim the content is a bool (i.e. no data will be read).",
                       GetName());
            }
         }
      }

  } else {
      if (TClassEdit::IsSTLCont(fClass->GetName())) {
         SetBit(kCanDelete);
         return;
      }
      const TObjArray *array = fClass->GetStreamerInfos();
      TStreamerInfo* info = 0;

      if (fClass->TestBit(TClass::kIsEmulation) && array->GetEntries()==0) {
         // We have an emulated class that has no TStreamerInfo, this
         // means it was created to insert a (default) rule.  Consequently
         // the error message about the missing dictionary was not printed.
         // For consistency, let's print it now!

         ::Warning("TClass::TClass", "no dictionary for class %s is available", GetName());
      }

      // Case of a custom collection (the user provided a CollectionProxy
      // for a class that is not an STL collection).
      if (GetElements()->GetEntries() == 1) {
         TObject *element = GetElements()->UncheckedAt(0);
         Bool_t isstl = element && strcmp("This",element->GetName())==0;
         if (isstl && !fClass->GetCollectionProxy()) {
            if (element->GetTitle()[0] == '<') {
               // We know the content.
               TString content = element->GetTitle();
               Int_t level = 1;
               for(Int_t c = 1; c < content.Length(); ++c) {
                  if (content[c] == '<') ++level;
                  else if (content[c] == '>') --level;
                  if (level == 0) {
                     content.Remove(c+1);
                     break;
                  }
               }
               content.Prepend("vector");
               TClass *clequiv = TClass::GetClass(content);
               TVirtualCollectionProxy *proxy = clequiv->GetCollectionProxy();
               if (gDebug > 1)
                  Info("BuildCheck",
                       "Update the collection proxy of the class \"%s\" \n"
                       "\tto be similar to \"%s\".",
                    GetName(),content.Data());
               fClass->CopyCollectionProxy( *proxy );
            } else {
               Warning("BuildCheck", "\n\
   The class %s had a collection proxy when written but it is not an STL\n \
   collection and we did not record the type of the content of the collection.\n \
   We will claim the content is a bool (i.e. no data will be read).",
                       GetName());
            }
            SetBit(kCanDelete);
            return;
         }
      }

      // If the user has not specified a class version (this _used to_
      // always be the case when the class is Foreign) or if the user
      // has specified a version to be explicitly 1. [We can not
      // distinguish the two cases using the information in the "on
      // file" StreamerInfo.]

      Bool_t searchOnChecksum = kFALSE;
      if (fClass->IsLoaded() && fClass->GetClassVersion() >= 2) {
         // We know for sure that the user specified the version.

         if (fOnFileClassVersion >= 2) {
            // The class version was specified when the object was
            // written

            searchOnChecksum = kFALSE;

         } else {
            // The class version was not specified when the object was
            // written OR it was specified to be 1.

            searchOnChecksum = kTRUE;
         }
      } else if (fClass->IsLoaded() && !fClass->IsForeign()) {
         // We are in the case where the class has a Streamer function.
         // and fClass->GetClassVersion is 1, we still assume that the
         // Class Version is specified (to be one).

         searchOnChecksum = kFALSE;

      } else if (fClass->IsLoaded() /* implied: && fClass->IsForeign() */ ) {
         // We are in the case of a Foreign class with no specified
         // class version.

         searchOnChecksum = kTRUE;

      }
      else {
         // We are in the case of an 'emulated' class.

         if (fOnFileClassVersion >= 2) {
            // The class version was specified when the object was
            // written

            searchOnChecksum = kFALSE;

         } else {
            // The class version was not specified when the object was
            // written OR it was specified to be 1.

            searchOnChecksum = kTRUE;

            TStreamerInfo* v1 = (TStreamerInfo*) array->At(1);
            if (v1) {
               if (fCheckSum != v1->GetCheckSum()) {
                  fClassVersion = array->GetLast() + 1;
               }
            }
         }
      }

      if (!searchOnChecksum) {
         if (fClassVersion < array->GetEntriesFast()) {
            info = (TStreamerInfo*) array->At(fClassVersion);
         }
      } else {
         Int_t ninfos = array->GetEntriesFast() - 1;
         for (Int_t i = -1; i < ninfos; ++i) {
            info = (TStreamerInfo*) array->UncheckedAt(i);
            if (!info) {
               continue;
            }
            if (fCheckSum == info->GetCheckSum() && (info->GetOnFileClassVersion()==1 || info->GetOnFileClassVersion()==0)) {
               // We must match on the same checksum, an existing TStreamerInfo
               // for one of the 'unversioned' class layout (i.e. version was 1).
               fClassVersion = i;
               break;
            }
            info = 0;
         }
         if (info==0) {
            // Find an empty slot.
            ninfos = array->GetEntriesFast() - 1;
            Int_t slot = 1; // Start of Class version 1.
            while ((slot < ninfos) && (array->UncheckedAt(slot) != 0)) {
               ++slot;
            }
            fClassVersion = slot;
         }
      }

      // NOTE: Should we check if the already existing info is the same as
      // the current one? Yes
      // In case a class (eg Event.h) has a TClonesArray of Tracks, it could be
      // that the old info does not have the class name (Track) in the data
      // member title. Set old title to new title
      if (info) {
         // We found an existing TStreamerInfo for our ClassVersion
         Bool_t match = kTRUE;
         Bool_t done = kFALSE;
         Bool_t oldIsNonVersioned = kFALSE;
         if (fClassVersion!=0 && !fClass->TestBit(TClass::kWarned) && (fClassVersion == info->GetClassVersion()) && (fCheckSum != info->GetCheckSum())) {
            // The TStreamerInfo's checksum is different from the checksum for the compile class.

            match = kFALSE;
            oldIsNonVersioned = info->fOnFileClassVersion==1 && info->fClassVersion != 1;

            if (fClass->IsLoaded() && (fClassVersion == fClass->GetClassVersion()) && fClass->HasDataMemberInfo()) {
               // In the case where the read-in TStreamerInfo does not
               // match in the 'current' in memory TStreamerInfo for
               // a non foreign class (we can not get here if this is
               // a foreign class so we do not need to test it),
               // we need to add this one more test since the CINT behaviour
               // with enums changed over time, so verify the checksum ignoring
               // members of type enum. We also used to not count the //[xyz] comment
               // in the checksum, so test for that too.
               if (  (fCheckSum == fClass->GetCheckSum() || fClass->MatchLegacyCheckSum(fCheckSum) )
                     &&(info->GetCheckSum() == fClass->GetCheckSum() || fClass->MatchLegacyCheckSum(info->GetCheckSum()))
                     )
                  {
                     match = kTRUE;
                  }
               if (fOldVersion <= 2) {
                  // Names of STL base classes was modified in vers==3. Allocators removed
                  // (We could be more specific (see test for the same case below)
                  match = kTRUE;
               }
               if (!match && CompareContent(0,info,kFALSE,kFALSE,file)) {
                  match = kTRUE;
               }
#ifdef TEST_FOR_BACKWARD_COMPATIBILITY_ABSTRACT_CLASSES
               if (!match && file->GetVersion() < 51800 && fClass && (fClass->Property() & kIsAbstract)
                   && fClass->GetListOfDataMembers()->GetEntries() != 0)
               {
                  // In some instances of old files (v5.17 and less), some StreamerInfo for
                  // an abstract class where not written correctly, and add no
                  // data member listed.  If in addition one of the data member
                  // was declared using a typedef _and_ the current class definition
                  // uses a different typedef, we are unable to recalculate the
                  // checksum as it was, because the information is missing from
                  // the StreamerInfo, and for the same reason CompareContent can
                  // not know whether this is okay or not ...
                  //
                  // Since this is such an unlikely scenario, let's complain
                  // about it anyway (The class layout *may* have changed, we
                  // don't know).

                  // if (this has only base classes) {
                  //    match = kTRUE;
                  // }
               }
#endif
            } else {
               // The on-file TStreamerInfo's checksum differs from the checksum of a TStreamerInfo on another file.

               match = kFALSE;
               oldIsNonVersioned = info->fOnFileClassVersion==1 && info->fClassVersion != 1;

               // In the case where the read-in TStreamerInfo does not
               // match in the 'current' in memory TStreamerInfo for
               // a non foreign class (we can not get here if this is
               // a foreign class so we do not need to test it),
               // we need to add this one more test since the CINT behaviour
               // with enums changed over time, so verify the checksum ignoring
               // members of type enum. We also used to not count the //[xyz] comment
               // in the checksum, so test for that too.
               if (fCheckSum == info->GetCheckSum(TClass::kCurrentCheckSum)
                   || info->MatchLegacyCheckSum(fCheckSum)
                   || GetCheckSum(TClass::kCurrentCheckSum) == info->fCheckSum
                   || MatchLegacyCheckSum(info->GetCheckSum())
                   || GetCheckSum(TClass::kCurrentCheckSum) == info->GetCheckSum(TClass::kCurrentCheckSum))
                  {
                     match = kTRUE;
                  }
               if (fOldVersion <= 2) {
                  // Names of STL base classes was modified in vers==3. Allocators removed
                  // (We could be more specific (see test for the same case below)
                  match = kTRUE;
               }
               if (!match && CompareContent(0,info,kFALSE,kFALSE,file)) {
                  match = kTRUE;
               }
            }
         }
         if (info->IsBuilt()) {
            SetBit(kCanDelete);
            fNumber = info->GetNumber();
            Int_t nel = fElements->GetEntriesFast();
            TObjArray* elems = info->GetElements();
            TStreamerElement* e1 = 0;
            TStreamerElement* e2 = 0;
            for (Int_t i = 0; i < nel; ++i) {
               e1 = (TStreamerElement*) fElements->UncheckedAt(i);
               e2 = (TStreamerElement*) elems->At(i);
               if (!e1 || !e2) {
                  continue;
               }
               if (strlen(e1->GetTitle()) != strlen(e2->GetTitle())) {
                  e2->SetTitle(e1->GetTitle());
               }
            }

            done = kTRUE;
         } else {
            fClass->RemoveStreamerInfo(fClassVersion);
            info = 0;
         }
         TString origin;
         if (!match && !fClass->TestBit(TClass::kWarned)) {
            if (oldIsNonVersioned) {
               if (file) {
                  Warning("BuildCheck", "\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 been\n\
   loaded so far.  This prevent the proper reading of objects written with\n\
   the class layout version %d, in particular from the file:\n\
   %s.\n\
   To work around this issue, load fewer 'old' files in the same ROOT session.",
                          GetName(),fClass->GetClassVersion(),fClassVersion,file->GetName());
               } else {
                  Warning("BuildCheck", "\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 been\n\
   loaded so far.  This prevent the proper reading of objects written with\n\
   the class layout version %d.\n\
   To work around this issue, load fewer 'old' files in the same ROOT session.",
                          GetName(),fClass->GetClassVersion(),fClassVersion);
               }
            } else {
               if (file) {
                  if (done) {
                     Warning("BuildCheck", "\n\
   The StreamerInfo for version %d of class %s read from the file %s\n\
   has a different checksum than the previously loaded StreamerInfo.\n\
   Reading objects of type %s from the file %s \n\
   (and potentially other files) might not work correctly.\n\
   Most likely the version number of the class was not properly\n\
   updated [See ClassDef(%s,%d)].",
                             fClassVersion, GetName(), file->GetName(), GetName(), file->GetName(), GetName(), fClassVersion);
                  } else {
                     Warning("BuildCheck", "\n\
   The StreamerInfo from %s does not match existing one (%s:%d)\n\
   The existing one has not been used yet and will be discarded.\n\
   Reading the file %s will work properly, however writing object of\n\
   type %s will not work properly.  Most likely the version number\n\
   of the class was not properly updated [See ClassDef(%s,%d)].",
                             file->GetName(), GetName(), fClassVersion,file->GetName(),GetName(), GetName(), fClassVersion);
                  }
               } else {
                  if (done) {
                     Warning("BuildCheck", "\n\
   The StreamerInfo for version %d of class %s\n\
   has a different checksum than the previously loaded StreamerInfo.\n\
   Reading objects of type %s\n\
   (and potentially other files) might not work correctly.\n\
   Most likely the version number of the class was not properly\n\
   updated [See ClassDef(%s,%d)].",
                             fClassVersion, GetName(), GetName(), GetName(), fClassVersion);
                  } else {
                     Warning("BuildCheck", "\n\
   The StreamerInfo from %s does not match existing one (%s:%d)\n\
   The existing one has not been used yet and will be discarded.\n\
   Reading should work properly, however writing object of\n\
   type %s will not work properly.  Most likely the version number\n\
   of the class was not properly updated [See ClassDef(%s,%d)].",
                             file->GetName(), GetName(), fClassVersion, GetName(), GetName(), fClassVersion);
                  }
               }
            }
            CompareContent(0,info,kTRUE,kTRUE,file);
            fClass->SetBit(TClass::kWarned);
         }
         if (done) {
            return;
         }
      }
      // The slot was free, however it might still be reserved for the current
      // loaded version of the class
      if (fClass->IsLoaded()
          && fClass->HasDataMemberInfo()
          && (fClassVersion != 0) // We don't care about transient classes
          && (fClassVersion == fClass->GetClassVersion())
          && (fCheckSum != fClass->GetCheckSum())) {

         // If the old TStreamerInfo matches the in-memory one when we either
         //   - ignore the members of type enum
         // or
         //   - ignore the comments annotation (//[xyz])
         // we can accept the old TStreamerInfo.

         if (!fClass->MatchLegacyCheckSum(fCheckSum)) {

            Bool_t warn = !fClass->TestBit(TClass::kWarned);
            if (warn) {
               warn = !CompareContent(fClass,0,kFALSE,kFALSE,file);
            }
#ifdef TEST_FOR_BACKWARD_COMPATIBILITY_ABSTRACT_CLASSES
            if (warn && file->GetVersion() < 51800 && fClass && (fClass->Property() & kIsAbstract)
                && fClass->GetListOfDataMembers()->GetEntries() != 0)
            {
               // In some instances of old files (v5.17 and less), some StreamerInfo for
               // an abstract class where not written correctly, and add no
               // data member listed.  If in addition one of the data member
               // was declared using a typedef _and_ the current class definition
               // uses a different typedef, we are unable to recalculate the
               // checksum as it was, because the information is missing from
               // the StreamerInfo, and for the same reason CompareContent can
               // not know whether this is okay or not ...
               //
               // Since this is such an unlikely scenario, let's complain
               // about it anyway (The class layout *may* have changed, we
               // don't know).

               // if (this has only base classes) {
               //    warn = kFALSE;
               // }
            }
#endif // TEST_FOR_BACKWARD_COMPATIBILITY
            if (warn && (fOldVersion <= 2)) {
               // Names of STL base classes was modified in vers==3. Allocators removed
               //
               TIter nextBC(fClass->GetListOfBases());
               TBaseClass* bc = 0;
               while ((bc = (TBaseClass*) nextBC())) {
                  if (TClassEdit::IsSTLCont(bc->GetName())) {
                     warn = kFALSE;
                  }
               }
            }
            if (warn) {
               if (file) {
                  Warning("BuildCheck", "\n\
   The StreamerInfo of class %s read from file %s\n\
   has the same version (=%d) as the active class but a different checksum.\n\
   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", GetName(), file->GetName(), fClassVersion, GetName(), fClassVersion + 1);
               } else {
                  Warning("BuildCheck", "\n\
   The StreamerInfo of class %s \n\
   has the same version (=%d) as the active class but a different checksum.\n\
   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", GetName(), fClassVersion, GetName(), fClassVersion + 1);
               }
               CompareContent(fClass,0,kTRUE,kTRUE,file);
               fClass->SetBit(TClass::kWarned);
            }
         } else {
            if (!fClass->IsVersioned()) {
               Fatal("BuildCheck", "\n\
   The StreamerInfo of unversioned class %s \n\
   has the same version (=%d) as the active class but an old checksum.\n\
   This should not happen. An assert will follow.\n", GetName(), fClassVersion);
            }
         }
      }
      if (!fClass->IsLoaded() &&  this->fOnFileClassVersion>1)
      {
         ROOT::ResetClassVersion(fClass,(const char*)-1, this->fClassVersion);
      }
   }
   // FIXME: This code can never execute because Build() calls
   // TStreamerElement::Class()->IgnoreTObjectStreamer()
   // so our bits are never saved to the file.
   if (TestBit(kIgnoreTObjectStreamer)) {
      fClass->IgnoreTObjectStreamer();
   }
   if ((fClassVersion < -1) || (fClassVersion > 65000)) {
      printf("ERROR reading TStreamerInfo: %s fClassVersion=%d\n", GetName(), fClassVersion);
      SetBit(kCanDelete);
      fNumber = -1;
      return;
   }

   if (!fClass->TestBit(TClass::kWarned)
       && fClass->GetState() >= TClass::kInterpreted
       && GetCheckSum() != fClass->GetCheckSum()
       && fClassVersion == fClass->GetClassVersion()) {
      // We got here, thus we are a perfect alias for the current streamerInfo,
      // but we might had odd v5 style name spelling, so let's prefer the
      // current one.
      SetBit(kCanDelete);
      return;
   }

   fClass->RegisterStreamerInfo(this);
   ++fgCount;
   fNumber = fgCount;

   // Since we just read this streamerInfo from file, it has already been built.
   fIsBuilt = kTRUE;

   //add to the global list of StreamerInfo
   TObjArray* infos = (TObjArray*) gROOT->GetListOfStreamerInfo();
   infos->AddAtAndExpand(this, fNumber);
}

//______________________________________________________________________________
void TStreamerInfo::BuildEmulated(TFile *file)
{
   // Create an Emulation TStreamerInfo object.

   R__LOCKGUARD(gInterpreterMutex);

   TString duName;
   R__ASSERT(file);
   Int_t fv = file->GetVersion()%100000;
   R__ASSERT(fv < 30000);
   fClassVersion = -1;
   fCheckSum = 2001;
   TObjArray *elements = GetElements();
   Int_t ndata = elements ? elements->GetEntries() : 0;
   for (Int_t i=0;i < ndata;i++) {
      TStreamerElement *element = (TStreamerElement*)elements->UncheckedAt(i);
      if (!element) break;
      int ty = element->GetType();
      if (ty < kChar || ty >kULong+kOffsetL)    continue;
      if (ty == kLong)                         element->SetType(kInt);
      if (ty == kULong)                         element->SetType(kUInt);
      if (ty == kLong + kOffsetL)                element->SetType(kInt + kOffsetL);
      if (ty == kULong + kOffsetL)                element->SetType(kUInt + kOffsetL);
      if (ty <= kULong)                         continue;
      duName = element->GetName();
      duName.Append("QWERTY");
      TStreamerBasicType *bt = new TStreamerBasicType(duName, "", 0, kInt,"Int_t");
      {for (int j=ndata-1;j>=i;j--) {elements->AddAtAndExpand(elements->At(j),j+1);}}
      elements->AddAt(bt,i);
      ndata++;
      i++;
   }
   BuildOld();
}

//______________________________________________________________________________
Bool_t TStreamerInfo::BuildFor( const TClass *in_memory_cl )
{
   //---------------------------------------------------------------------------
   // Check if we can build this for foreign class - do we have some rules
   // to do that
   //---------------------------------------------------------------------------
   R__LOCKGUARD(gInterpreterMutex);

   if( !in_memory_cl || !in_memory_cl->GetSchemaRules() ) {
      return kFALSE;
   }

   const TObjArray* rules;

   rules = in_memory_cl->GetSchemaRules()->FindRules( GetName(), fOnFileClassVersion, fCheckSum );

   if( !rules && !TClassEdit::IsSTLCont( in_memory_cl->GetName() ) ) {
      Warning( "BuildFor", "The build of %s streamer info for %s has been requested, but no matching conversion rules were specified", GetName(), in_memory_cl->GetName() );
      return kFALSE;
   }

   fClass = const_cast<TClass*>(in_memory_cl);

   return kTRUE;
}

//______________________________________________________________________________
// Helper function for BuildOld
namespace {
   Bool_t ClassWasMovedToNamespace(TClass *oldClass, TClass *newClass)
   {
      // Returns true if oldClass is the same as newClass but newClass is in a
      // namespace (and oldClass was not in a namespace).

      if (oldClass == 0 || newClass == 0) return kFALSE;

      UInt_t newlen = strlen(newClass->GetName());
      UInt_t oldlen = strlen(oldClass->GetName());

      const char *oldname = oldClass->GetName();
      for (UInt_t i = oldlen, done = false, nest = 0; (i>0) && !done ; --i) {
         switch (oldClass->GetName()[i-1]) {
            case '>' : ++nest; break;
            case '<' : if (nest==0) return kFALSE; // the name is not well formed, give up.
                       --nest; break;
            case ':' : if (nest == 0) oldname= &(oldClass->GetName()[i]); done = kTRUE; break;
         }
      }
      oldlen = strlen(oldname);
      if (!(strlen(newClass->GetName()) > strlen(oldClass->GetName()))) {
         return kFALSE;
      }

      const char* newEnd = & (newClass->GetName()[newlen-oldlen]);

      if (0 != strcmp(newEnd, oldname)) {
         return kFALSE;
      }

      Int_t oldv = oldClass->GetStreamerInfo()->GetClassVersion();

      if (newClass->GetStreamerInfos() && oldv < newClass->GetStreamerInfos()->GetSize() && newClass->GetStreamerInfos()->At(oldv) && strcmp(newClass->GetStreamerInfos()->At(oldv)->GetName(), oldClass->GetName()) != 0) {
         // The new class has already a TStreamerInfo for the the same version as
         // the old class and this was not the result of an import.  So we do not
         // have a match
         return kFALSE;
      }
      return kTRUE;
   }

   Int_t ImportStreamerInfo(TClass *oldClass, TClass *newClass) {
      // Import the streamerInfo from oldClass to newClass
      // In case of conflict, returns the version number of the StreamerInfo
      // with the conflict.
      // Return 0 in case of success

      TIter next(oldClass->GetStreamerInfos());
      TStreamerInfo *info;
      while ((info = (TStreamerInfo*)next())) {
         info = (TStreamerInfo*)info->Clone();
         if (!info) {
            Error("ImportStreamerInfo","Unable to clone the StreamerInfo for %s.",(*next)->GetName());
         } else {
            info->SetClass(newClass);
            Int_t oldv = info->GetClassVersion();
            if (oldv > newClass->GetStreamerInfos()->GetSize() || newClass->GetStreamerInfos()->At(oldv) == 0) {
               // All is good.
               newClass->RegisterStreamerInfo(info);
            } else {
               // We verify that we are consistent and that
               //   newcl->GetStreamerInfos()->UncheckedAt(info->GetClassVersion)
               // is already the same as info.
               if (strcmp(newClass->GetStreamerInfos()->At(oldv)->GetName(),
                          oldClass->GetName()) != 0) {
                  // The existing StreamerInfo does not already come from OldClass.
                  // This is a real problem!
                  return oldv;
               }
            }
         }
      }
      return 0;
   }

   Bool_t ContainerMatchTClonesArray(TClass *newClass)
   {
      // Return true if newClass is a likely valid conversion from
      // a TClonesArray

      return newClass->GetCollectionProxy()
             && newClass->GetCollectionProxy()->GetValueClass()
             && !newClass->GetCollectionProxy()->HasPointers();
   }

   Bool_t CollectionMatch(const TClass *oldClass, const TClass* newClass)
   {
      // Return true if oldClass and newClass points to 2 compatible collection.
      // i.e. they contains the exact same type.

      TVirtualCollectionProxy *oldProxy = oldClass->GetCollectionProxy();
      TVirtualCollectionProxy *newProxy = newClass->GetCollectionProxy();

      TClass *oldContent = oldProxy->GetValueClass();
      TClass *newContent = newProxy->GetValueClass();

      Bool_t contentMatch = kFALSE;
      if (oldContent) {
         if (oldContent == newContent) {
            contentMatch = kTRUE;
         } else if (newContent) {
            TString oldFlatContent( TMakeProject::UpdateAssociativeToVector(oldContent->GetName()) );
            TString newFlatContent( TMakeProject::UpdateAssociativeToVector(newContent->GetName()) );
            if (oldFlatContent == newFlatContent) {
               contentMatch = kTRUE;
            }
         } else {
            contentMatch = kFALSE;
         }
      } else {
         contentMatch = (newContent==0);
      }

      if (contentMatch) {
         if ((oldContent==0 && oldProxy->GetType() == newProxy->GetType())
             ||(oldContent && oldProxy->HasPointers() == newProxy->HasPointers())) {
            // We have compatibles collections (they have the same content)!
            return kTRUE;
         }
      }
      return kFALSE;
   }

   Bool_t CollectionMatchFloat16(const TClass *oldClass, const TClass* newClass)
   {
      // Return true if oldClass and newClass points to 2 compatible collection.
      // i.e. they contains the exact same type.

      TVirtualCollectionProxy *oldProxy = oldClass->GetCollectionProxy();
      TVirtualCollectionProxy *newProxy = newClass->GetCollectionProxy();

      if (oldProxy->GetValueClass() == 0 && newProxy->GetValueClass() == 0
          && (oldProxy->GetType() == kFloat_t || oldProxy->GetType() == kFloat16_t)
          && (newProxy->GetType() == kFloat_t || newProxy->GetType() == kFloat16_t )) {
            // We have compatibles collections (they have the same content)!
         return (TClassEdit::IsSTLCont(oldClass->GetName()) == TClassEdit::IsSTLCont(newClass->GetName()));
      }
      return kFALSE;
   }

   Bool_t CollectionMatchDouble32(const TClass *oldClass, const TClass* newClass)
   {
      // Return true if oldClass and newClass points to 2 compatible collection.
      // i.e. they contains the exact same type.

      TVirtualCollectionProxy *oldProxy = oldClass->GetCollectionProxy();
      TVirtualCollectionProxy *newProxy = newClass->GetCollectionProxy();

      if (oldProxy->GetValueClass() == 0 && newProxy->GetValueClass() == 0
          && (oldProxy->GetType() == kDouble_t || oldProxy->GetType() == kDouble32_t)
          && (newProxy->GetType() == kDouble_t || newProxy->GetType() == kDouble32_t )) {
            // We have compatibles collections (they have the same content)!
         return (TClassEdit::IsSTLCont(oldClass->GetName()) == TClassEdit::IsSTLCont(newClass->GetName()));
      }
      return kFALSE;
   }

   Bool_t CollectionMatchLong64(const TClass *oldClass, const TClass* newClass)
   {
      // Return true if oldClass and newClass points to 2 compatible collection.
      // i.e. they contains the exact same type.

      TVirtualCollectionProxy *oldProxy = oldClass->GetCollectionProxy();
      TVirtualCollectionProxy *newProxy = newClass->GetCollectionProxy();

      if (oldProxy->GetValueClass() == 0 && newProxy->GetValueClass() == 0
          && (oldProxy->GetType() == kLong_t || oldProxy->GetType() == kLong64_t)
          && (newProxy->GetType() == kLong_t || newProxy->GetType() == kLong64_t )) {
         // We have compatibles collections (they have the same content)!
         return (TClassEdit::IsSTLCont(oldClass->GetName()) == TClassEdit::IsSTLCont(newClass->GetName()));
      }
      return kFALSE;
   }

   Bool_t CollectionMatchULong64(const TClass *oldClass, const TClass* newClass)
   {
      // Return true if oldClass and newClass points to 2 compatible collection.
      // i.e. they contains the exact same type.

      TVirtualCollectionProxy *oldProxy = oldClass->GetCollectionProxy();
      TVirtualCollectionProxy *newProxy = newClass->GetCollectionProxy();

      if (oldProxy->GetValueClass() == 0 && newProxy->GetValueClass() == 0
          && (oldProxy->GetType() == kULong_t || oldProxy->GetType() == kULong64_t)
          && (newProxy->GetType() == kULong_t || newProxy->GetType() == kULong64_t )) {
         // We have compatibles collections (they have the same content)!
         return (TClassEdit::IsSTLCont(oldClass->GetName()) == TClassEdit::IsSTLCont(newClass->GetName()));
      }
      return kFALSE;
   }

   TClass *FindAlternate(TClass *context, const std::string &i_name, std::string& newName)
   {
      // Return a class whose has the name as oldClass and can be found
      // within the scope of the class 'context'.

      // First strip any 'const ' prefix or trailing '*'.
      std::string name(i_name);
      newName.clear();
      if (name.compare(0,6,"const ")==0) {
         newName = "const ";
         name.erase(0,6);
      }
      std::string suffix;
      UInt_t nstars = 0;
      while(name[name.length()-nstars-1]=='*') {
         ++nstars;
         suffix.append("*");
      }
      if (nstars) {
         name.erase(name.length()-nstars,nstars);
      }

      std::string alternate(context->GetName());
      alternate.append("::");
      alternate.append(name);

      TClass *altcl = TClass::GetClass(alternate.c_str(),/*load=*/ false,true);
      if (altcl) {
         newName.append(altcl->GetName());
         newName.append(suffix);
         return altcl;
      }

      size_t ctxt_cursor = strlen(context->GetName());
      for (size_t level = 0; ctxt_cursor != 0; --ctxt_cursor) {
         switch (context->GetName()[ctxt_cursor]) {
            case '<': --level; break;
            case '>': ++level; break;
            case ':': if (level == 0) {
               // we encountered a scope not within a template
               // parameter.
               alternate.clear();
               alternate.append(context->GetName(),ctxt_cursor+1);
               alternate.append(name);
               altcl = TClass::GetClass(alternate.c_str(),/*load=*/ false,true);
               if (altcl) {
                  newName.append(altcl->GetName());
                  newName.append(suffix);
                  return altcl;
               }
            }
         }
      }
      newName.clear();
      return 0;
   }

   bool HasScope(const std::string &name)
   {
      // return true if the type name has a scope in it.

      for(size_t i = 0, level = 0; i<name.length(); ++i) {
         switch (name[i]) {
            case '<': ++level; break;
            case '>': --level; break;
            case ':': if (level == 0) {
               // we encountered a scope not within a template
               // parameter.
               return true;
            }
         }
      } // for each in name
      return false;
   }

   TClass *FixCollectionV5(TClass *context, TClass *oldClass, TClass *newClass)
   {
      assert(oldClass->GetCollectionProxy() && newClass->GetCollectionProxy());

      TVirtualCollectionProxy *old = oldClass->GetCollectionProxy();
      TVirtualCollectionProxy *current = newClass->GetCollectionProxy();
      Int_t stlkind = old->GetCollectionType();

      if (stlkind == ROOT::kSTLmap || stlkind == ROOT::kSTLmultimap) {

         TVirtualStreamerInfo *info = current->GetValueClass()->GetStreamerInfo();
         if (info->GetElements()->GetEntries() != 2) {
            return oldClass;
         }
         TStreamerElement *f = (TStreamerElement*) info->GetElements()->At(0);
         TStreamerElement *s = (TStreamerElement*) info->GetElements()->At(1);

         info = old->GetValueClass()->GetStreamerInfo();
         assert(info->GetElements()->GetEntries() == 2);
         TStreamerElement *of = (TStreamerElement*) info->GetElements()->At(0);
         TStreamerElement *os = (TStreamerElement*) info->GetElements()->At(1);

         TClass *firstNewCl  = f ? f->GetClass() : 0;
         TClass *secondNewCl = s ? s->GetClass() : 0;

         TClass *firstOldCl  = of ? of->GetClass() : 0;
         TClass *secondOldCl = os ? os->GetClass() : 0;

         if ((firstNewCl && !firstOldCl) || (secondNewCl && !secondOldCl))
         {
            std::vector<std::string> inside;
            int nestedLoc;
            TClassEdit::GetSplit( oldClass->GetName(), inside, nestedLoc, TClassEdit::kLong64 );

            TClass *firstAltCl = firstOldCl;
            TClass *secondAltCl = secondOldCl;
            std::string firstNewName;
            std::string secondNewName;
            if (firstNewCl && !HasScope(inside[1])) {
               firstAltCl = FindAlternate(context, inside[1], firstNewName);
            }
            if (secondNewCl && !HasScope(inside[2])) {
               secondAltCl = FindAlternate(context, inside[2], secondNewName);
            }
            if ((firstNewCl && firstAltCl != firstOldCl) ||
                (secondNewCl && secondAltCl != secondOldCl) ) {

               // Need to produce new name.
               std::string alternate = inside[0];
               alternate.append("<");
               alternate.append(firstAltCl ? firstNewName : inside[1]);
               alternate.append(",");
               alternate.append(secondAltCl? secondNewName : inside[2]);
               // We are intentionally dropping any further arguments,
               // they would be using the wrong typename and would also be
               // somewhat superflous since this is for the old layout.
               if (alternate[alternate.length()-1]=='>') {
                  alternate.append(" ");
               }
               alternate.append(">");
               return TClass::GetClass(alternate.c_str(),true,true);
            }
         }

      } else if (current->GetValueClass() && !old->GetValueClass()
          && old->GetType() == kInt_t) {

         // The old CollectionProxy claims it contains int (or enums) while
         // the new one claims to contain a class.  It is likely that we have
         // in the collection name a class (typedef) name that is missing its
         // scope.  Let's try to check.

         std::vector<std::string> inside;
         int nestedLoc;
         TClassEdit::GetSplit( oldClass->GetName(), inside, nestedLoc, TClassEdit::kLong64 );

         // Does the type already have a scope, in which case,
         // (at least for now), let's assume it is already fine.
         if (HasScope(inside[1])) {
            return oldClass;
         }

         // Now let's if we can find this missing type.
         std::string newName;
         TClass *altcl = FindAlternate(context, inside[1], newName);

         if (altcl) {
            std::string alternate = inside[0];
            alternate.append("<");
            alternate.append(newName);
            // We are intentionally dropping any further arguments,
            // they would be using the wrong typename and would also be
            // somewhat superflous since this is for the old layout.
            if (alternate[alternate.length()-1]=='>') {
               alternate.append(" ");
            }
            alternate.append(">");
            return TClass::GetClass(alternate.c_str(),true,true);
         }
      }
      return 0;
   }

   // Makes sure kBuildOldUsed set once BuildOld finishes
   struct TBuildOldGuard {
      TBuildOldGuard(TStreamerInfo* info): fInfo(info) {
         fInfo->SetBit(TStreamerInfo::kBuildRunning);
      }
      ~TBuildOldGuard() {
         fInfo->ResetBit(TStreamerInfo::kBuildRunning);
         fInfo->SetBit(TStreamerInfo::kBuildOldUsed);
      }
      TStreamerInfo* fInfo;
   };
}

//______________________________________________________________________________
void TStreamerInfo::BuildOld()
{
   // rebuild the TStreamerInfo structure

   R__LOCKGUARD(gInterpreterMutex);

   if ( TestBit(kBuildOldUsed) ) return;

   // Are we recursing on ourself?
   if (TestBit(TStreamerInfo::kBuildRunning)) return;

   // This is used to avoid unwanted recursive call to Build and make sure
   // that we record the execution of BuildOld.
   TBuildOldGuard buildOldGuard(this);

   if (gDebug > 0) {
      printf("\n====>Rebuilding TStreamerInfo for class: %s, version: %d\n", GetName(), fClassVersion);
   }

   Bool_t wasCompiled = IsCompiled();

   if (fClass->GetClassVersion() == fClassVersion) {
      if (!fClass->HasInterpreterInfo() || TClassEdit::IsSTLCont(GetName(), 0) || TClassEdit::IsSTLBitset(GetName()))
      {
         // Handle emulated classes and STL containers specially.
         // in this case BuildRealData would call BuildOld for this same
         // TStreamerInfo to be able to build the real data on it.
      } else {
         fClass->BuildRealData();
      }
   }
   else {
      // This is to support the following case
      //  Shared library: Event v2
      //  calling cl->GetStreamerInfo(1)->BuildOld();  (or equivalent)
      //  which calls cl->BuildReadData()
      //  which set fRealData to some value
      //  then call Event()
      //  which call cl->GetStreamerInfo()
      //  which call cl->BuildRealData();
      //  which returns immediately (upon seeing fRealData!=0)
      //  then the main StreamerInfo build using the partial content of fRealData
      //  then BuildRealData returns
      //  then GetStreamerInfo() returns
      //  then Event() returns
      //  then fRealData is finished being populated
      //  then this function continue,
      //  then it uses the main streamerInfo
      //  .... which is incomplete.
      //
      //  Instead we force the creation of the main streamerInfo object
      //  before the creation of fRealData.
      fClass->GetStreamerInfo();
   }

   TIter next(fElements);
   TStreamerElement* element;
   Int_t offset = 0;
   TMemberStreamer* streamer = 0;

   Int_t sp = sizeof(void*);

   int nBaze = 0;

   if ((fElements->GetEntries() == 1) && !strcmp(fElements->At(0)->GetName(), "This")) {
      if (fClass->GetCollectionProxy())  {
         element = (TStreamerElement*)next();
         element->SetNewType( element->GetType() );
         element->SetNewClass( fClass );
      } else if (((TStreamerElement*)fElements->At(0))->GetType() == TStreamerInfo::kSTL &&
                 strcmp( ((TStreamerElement*)fElements->At(0))->GetTypeName(),GetName()) != 0) {
         // We have a collection that was proxied but does not have a collection proxy,
         // let's put one in place just for fun ... humm however we have no clue what is the value
         // type ....

         // For now wild guess ....

      }
   }

   TClass *allocClass = 0;
   TStreamerInfo *infoalloc = 0;

   //---------------------------------------------------------------------------
   // Get schema rules for this class
   //---------------------------------------------------------------------------
   const ROOT::TSchemaMatch*   rules   = 0;
   const ROOT::TSchemaRuleSet* ruleSet = fClass->GetSchemaRules();

   rules = (ruleSet ? ruleSet->FindRules( GetName(), fOnFileClassVersion, fCheckSum ) : 0);

   Bool_t shouldHaveInfoLoc = fClass->TestBit(TClass::kIsEmulation) && !TClassEdit::IsStdClass(fClass->GetName());
   Int_t virtualInfoLocAlloc = 0;
   fNVirtualInfoLoc = 0;
   delete [] fVirtualInfoLoc;
   fVirtualInfoLoc = 0;

   while ((element = (TStreamerElement*) next())) {
      if (element->IsA()==TStreamerArtificial::Class()
          || element->TestBit(TStreamerElement::kCache) )
      {
         // Prevent BuildOld from modifying existing ArtificialElement (We need to review when and why BuildOld
         // needs to be re-run; it might be needed if the 'current' class change (for example from being an onfile
         // version to being a version loaded from a shared library) and we thus may have to remove the artifical
         // element at the beginning of BuildOld)

         continue;
      };

      element->SetNewType(element->GetType());
      if (element->IsBase()) {
         //---------------------------------------------------------------------
         // Dealing with nonSTL bases
         //---------------------------------------------------------------------
         if (element->IsA() == TStreamerBase::Class()) {
            TStreamerBase* base = (TStreamerBase*) element;
#if defined(PROPER_IMPLEMEMANTION_OF_BASE_CLASS_RENAMING)
            TClass* baseclass =  fClass->GetBaseClass( base->GetName() );
#else
            // Currently the base class renaming does not work, so we use the old
            // version of the code which essentially disable the next if(!baseclass ..
            // statement.
            TClass* baseclass =  base->GetClassPointer();
#endif

            //------------------------------------------------------------------
            // We do not have this base class - check if we're renaming
            //------------------------------------------------------------------
            if( !baseclass && !fClass->TestBit( TClass::kIsEmulation ) ) {
               const ROOT::TSchemaRule* rule = (rules ? rules->GetRuleWithSource( base->GetName() ) : 0);

               //---------------------------------------------------------------
               // No renaming, sorry
               //---------------------------------------------------------------
               if( !rule ) {
                  Error("BuildOld", "Could not find base class: %s for %s and could not find any matching rename rule\n", base->GetName(), GetName());
                  continue;
               }

               //----------------------------------------------------------------
               // Find a new target class
               //----------------------------------------------------------------
               const TObjArray* targets = rule->GetTarget();
               if( !targets ) {
                  Error("BuildOld", "Could not find base class: %s for %s, renaming rule was found but is malformed\n", base->GetName(), GetName());
               }
               TString newBaseClass = ((TObjString*)targets->At(0))->GetString();
               baseclass = TClass::GetClass( newBaseClass );
               base->SetNewBaseClass( baseclass );
            }
            //-------------------------------------------------------------------
            // No base class in emulated mode
            //-------------------------------------------------------------------
            else if( !baseclass ) {
               baseclass = base->GetClassPointer();
               if (!baseclass) {
                  Warning("BuildOld", "Missing base class: %s skipped", base->GetName());
                  // FIXME: Why is the version number 1 here? Answer: because we don't know any better at this point
                  baseclass = new TClass(element->GetName(), 1, 0, 0, -1, -1);
                  element->Update(0, baseclass);
               }
            }
            baseclass->BuildRealData();

            // Calculate the offset using the 'real' base class name (as opposed to the
            // '@@emulated' in the case of the emulation of an abstract base class.
            Int_t baseOffset = fClass->GetBaseClassOffset(baseclass);

            // Deal with potential schema evolution (renaming) of the base class.
            if (baseOffset < 0) {

               // See if this base element can be converted into one of
               // the existing base class.
               TList* listOfBases = fClass->GetListOfBases();
               if (listOfBases) {
                  TBaseClass* bc = 0;
                  TIter nextBC(fClass->GetListOfBases());
                  while ((bc = (TBaseClass*) nextBC())) {
                     TClass *in_memory_bcl = bc->GetClassPointer();
                     if (in_memory_bcl && in_memory_bcl->GetSchemaRules()) {
                        auto baserule = in_memory_bcl->GetSchemaRules()->FindRules( base->GetName(), base->GetBaseVersion(), base->GetBaseCheckSum() );
                        if (baserule) {
                           base->SetNewBaseClass(in_memory_bcl);
                           baseOffset = bc->GetDelta();

                        }
                     }
                  }
               }
            }
            // We need to initialize the element now, as we need the
            // correct StraemerInfo next.
            element->Init(this);

            // Force the StreamerInfo "Compilation" of the base classes first. This is necessary in
            // case the base class contains a member used as an array dimension in the derived classes.
            TStreamerInfo* infobase;
            if (fClass->TestBit(TClass::kIsEmulation) && (baseclass->Property() & kIsAbstract)) {
               Int_t version = base->GetBaseVersion();
               if (version >= 0 || base->GetBaseCheckSum() == 0) {
                  infobase = (TStreamerInfo*)baseclass->GetStreamerInfoAbstractEmulated(version);
               } else {
                  infobase = (TStreamerInfo*)baseclass->FindStreamerInfoAbstractEmulated(base->GetBaseCheckSum());
               }
               if (infobase) baseclass = infobase->GetClass();
            }
            else {
               infobase = (TStreamerInfo*)base->GetBaseStreamerInfo();
            }

            if (infobase && infobase->fComp == 0) {
               infobase->BuildOld();
            }

            if (infobase && shouldHaveInfoLoc && baseclass->TestBit(TClass::kIsEmulation) ) {
               if ( (fNVirtualInfoLoc + infobase->fNVirtualInfoLoc) > virtualInfoLocAlloc ) {
                  ULong_t *store = fVirtualInfoLoc;
                  virtualInfoLocAlloc = 16 * ( (fNVirtualInfoLoc + infobase->fNVirtualInfoLoc) / 16 + 1);
                  fVirtualInfoLoc = new ULong_t[virtualInfoLocAlloc];
                  if (store) {
                     memcpy(fVirtualInfoLoc, store, sizeof(ULong_t)*fNVirtualInfoLoc);
                     delete [] store;
                  }
               }
               for (int nloc = 0; nloc < infobase->fNVirtualInfoLoc; ++nloc) {
                  fVirtualInfoLoc[ fNVirtualInfoLoc + nloc ] = baseOffset + infobase->fVirtualInfoLoc[nloc];
               }
               fNVirtualInfoLoc += infobase->fNVirtualInfoLoc;
            }


            {
               if (baseOffset < 0) {
                  element->SetNewType(-1);
               }
            }
            element->SetOffset(baseOffset);
            offset += baseclass->Size();

            continue;
         } else {
            // Not a base elem but still base, string or STL as a base
            nBaze++;
            TList* listOfBases = fClass->GetListOfBases();
            Int_t baseOffset = -1;
            Int_t asize = 0;
            if (listOfBases) {
               // Do a search for the classname and some of its alternatives spelling.

               TBaseClass* bc = 0;
               TIter nextBC(fClass->GetListOfBases());
               while ((bc = (TBaseClass*) nextBC())) {
                  if (strchr(bc->GetName(), '<') || !strcmp(bc->GetName(),"string")) {
                     TString bcName(TClassEdit::ShortType(bc->GetName(), TClassEdit::kDropStlDefault).c_str());
                     TString elName(TClassEdit::ShortType(element->GetTypeName(), TClassEdit::kDropStlDefault).c_str());
                     if (bcName == elName) {
                        break;
                     }
                  }
               }

               if (!bc) {
                  Error("BuildOld", "Could not find STL base class: %s for %s\n", element->GetName(), GetName());
                  continue;
               } else if (bc->GetClassPointer()->GetCollectionProxy()
                          && !bc->GetClassPointer()->IsLoaded()
                          && bc->GetClassPointer()->GetCollectionProxy()->GetCollectionType() != ROOT::kSTLvector) {
                  Error("BuildOld","The class \"%s\" is compiled and its base class \"%s\" is a collection and we do not have a dictionary for it, we will not be able to read or write this base class.",GetName(),bc->GetName());
                  offset = kMissing;
                  element->SetOffset(kMissing);
                  element->SetNewType(-1);
                  continue;
               }
               baseOffset = bc->GetDelta();
               asize = bc->GetClassPointer()->Size();

            } else if (fClass->TestBit( TClass::kIsEmulation )) {
               // Do a search for the classname and some of its alternatives spelling.

               TStreamerInfo* newInfo = (TStreamerInfo*) fClass->GetStreamerInfos()->At(fClass->GetClassVersion());
               if (newInfo == this) {
                  baseOffset = offset;
                  asize = element->GetSize();
               } else if (newInfo) {
                  TIter newElems( newInfo->GetElements() );
                  TStreamerElement *newElement;
                  while( (newElement = (TStreamerElement*)newElems()) ) {
                     const char *newElName = newElement->GetName();
                     if (newElement->IsBase() && (strchr(newElName,'<') || !strcmp(newElName,"string")) ) {
                        TString bcName(TClassEdit::ShortType(newElName, TClassEdit::kDropStlDefault).c_str());
                        TString elName(TClassEdit::ShortType(element->GetTypeName(), TClassEdit::kDropStlDefault).c_str());
                        if (bcName == elName) {
                           break;
                        }
                     }
                  }
                  if (!newElement) {
                     Error("BuildOld", "Could not find STL base class: %s for %s\n", element->GetName(), GetName());
                     continue;
                  }
                  baseOffset = newElement->GetOffset();
                  asize = newElement->GetSize();
               }
            }
            if (baseOffset == -1) {
               TClass* cb = element->GetClassPointer();
               if (!cb) {
                  element->SetNewType(-1);
                  continue;
               }
               asize = cb->Size();
               baseOffset = fClass->GetBaseClassOffset(cb);
            }

            //  we know how to read but do we know where to read?
            if (baseOffset < 0) {
               element->SetNewType(-1);
               continue;
            }
            element->SetOffset(baseOffset);
            offset += asize;
            element->Init(this);
            continue;
         }
      }

      // If we get here, this means that we looked at all the base classes.
      if (shouldHaveInfoLoc && fNVirtualInfoLoc==0) {
         fNVirtualInfoLoc = 1;
         fVirtualInfoLoc = new ULong_t[1]; // To allow for a single delete statement.
         fVirtualInfoLoc[0] = offset;
         offset += sizeof(TStreamerInfo*);
      }

      TDataMember* dm = 0;

      // First set the offset and sizes.
      if (fClass->GetState() <= TClass::kEmulated) {
         // Note the initilization in this case are
         // delayed until __after__ the schema evolution
         // section, just in case the info has changed.

         // We are in the emulated case
         streamer = 0;
         element->Init(this);
      } else {
         // The class is known to Cling (and thus is not emulated)
         // and we need to use the real offsets.
         // However we may not have a 'proper' TClass for it
         // (in which case IsLoaded will be false and GetImplFileLine will be -1)

         // First look for the data member in the current class
         dm = (TDataMember*) fClass->GetListOfDataMembers()->FindObject(element->GetName());
         if (dm && dm->IsPersistent()) {
            fClass->BuildRealData();
            streamer = 0;
            offset = GetDataMemberOffset(dm, streamer);
            element->SetOffset(offset);
            element->Init(this);
            // We have a loaded class, let's make sure that if we have a collection
            // it is also loaded.
            TString dmClassName = TClassEdit::ShortType(dm->GetTypeName(),TClassEdit::kDropStlDefault).c_str();
            dmClassName = dmClassName.Strip(TString::kTrailing, '*');
            if (dmClassName.Index("const ")==0) dmClassName.Remove(0,6);
            TClass *elemDm = !dm->IsBasic() ? TClass::GetClass(dmClassName.Data()) : 0;
            if (elemDm && elemDm->GetCollectionProxy()
                && !elemDm->IsLoaded()
                && elemDm->GetCollectionProxy()->GetCollectionType() != ROOT::kSTLvector) {
               Error("BuildOld","The class \"%s\" is compiled and for its data member \"%s\", we do not have a dictionary for the collection \"%s\", we will not be able to read or write this data member.",GetName(),dm->GetName(),elemDm->GetName());
               offset = kMissing;
               element->SetOffset(kMissing);
               element->SetNewType(-1);
            }
            element->SetStreamer(streamer);
            int narr = element->GetArrayLength();
            if (!narr) {
               narr = 1;
            }
            int dsize = dm->GetUnitSize();
            element->SetSize(dsize*narr);
         } else {
            // We did not find it, let's look for it in the base classes via TRealData
            TRealData* rd = fClass->GetRealData(element->GetName());
            if (rd && rd->GetDataMember()) {
               element->SetOffset(rd->GetThisOffset());
               element->Init(this);
               dm = rd->GetDataMember();
               int narr = element->GetArrayLength();
               if (!narr) {
                  narr = 1;
               }
               int dsize = dm->GetUnitSize();
               element->SetSize(dsize*narr);
            }
         }
      }

      // Now let's deal with Schema evolution
      Int_t newType = -1;
      TClassRef newClass;

      if (dm && dm->IsPersistent()) {
         if (dm->GetDataType()) {
            Bool_t isPointer = dm->IsaPointer();
            Bool_t isArray = element->GetArrayLength() >= 1;
            Bool_t hasCount = element->HasCounter();
            // data member is a basic type
            if ((fClass == TObject::Class()) && !strcmp(dm->GetName(), "fBits")) {
               //printf("found fBits, changing dtype from %d to 15\n", dtype);
               newType = kBits;
            } else {
               // All the values of EDataType have the same semantic in EReadWrite
               newType = (EReadWrite)dm->GetDataType()->GetType();
            }
            if ((newType == ::kChar_t) && isPointer && !isArray && !hasCount) {
               newType = ::kCharStar;
            } else if (isPointer) {
               newType += kOffsetP;
            } else if (isArray) {
               newType += kOffsetL;
            }
         }
         if (newType == -1) {
            newClass = TClass::GetClass(dm->GetTypeName());
         }
      } else {
         // Either the class is not loaded or the data member is gone
         if (!fClass->IsLoaded()) {
            TStreamerInfo* newInfo = (TStreamerInfo*) fClass->GetStreamerInfos()->At(fClass->GetClassVersion());
            if (newInfo && (newInfo != this)) {
               TStreamerElement* newElems = (TStreamerElement*) newInfo->GetElements()->FindObject(element->GetName());
               newClass = newElems ?  newElems->GetClassPointer() : 0;
               if (newClass == 0) {
                  newType = newElems ? newElems->GetType() : -1;
                  if (!(newType < kObject)) {
                     // sanity check.
                     newType = -1;
                  }
               }
            } else {
               newClass = element->GetClassPointer();
               if (newClass.GetClass() == 0) {
                  newType = element->GetType();
                  if (!(newType < kObject)) {
                     // sanity check.
                     newType = -1;
                  }
               }
            }
         }
      }

      if (newType > 0) {
         // Case of a numerical type
         if (element->GetType() >= TStreamerInfo::kObject) {
            // Old type was not a numerical type.
            element->SetNewType(-2);
         } else if (element->GetType() != newType) {
            element->SetNewType(newType);
            if (gDebug > 0) {
               // coverity[mixed_enums] - All the values of EDataType have the same semantic in EReadWrite
               Info("BuildOld", "element: %s %s::%s has new type: %s/%d", element->GetTypeName(), GetName(), element->GetName(), dm ? dm->GetFullTypeName() : TDataType::GetTypeName((EDataType)newType), newType);
            }
         }
      } else if (newClass.GetClass()) {
         // Sometime BuildOld is called again.
         // In that case we migth already have fix up the streamer element.
         // So we need to go back to the original information!
         newClass.Reset();
         TClass* oldClass = TClass::GetClass(TClassEdit::ShortType(element->GetTypeName(), TClassEdit::kDropTrailStar).c_str());
         if (oldClass == newClass.GetClass()) {
            // Nothing to do :)
         } else if (ClassWasMovedToNamespace(oldClass, newClass.GetClass())) {
            Int_t oldv;
            if (0 != (oldv = ImportStreamerInfo(oldClass, newClass.GetClass()))) {
                Warning("BuildOld", "Can not properly load the TStreamerInfo from %s into %s due to a conflict for the class version %d", oldClass->GetName(), newClass->GetName(), oldv);
            } else {
               element->SetTypeName(newClass->GetName());
               if (gDebug > 0) {
                  Warning("BuildOld", "element: %s::%s %s has new type %s", GetName(), element->GetTypeName(), element->GetName(), newClass->GetName());
               }
            }
         } else if (oldClass == TClonesArray::Class()) {
            if (ContainerMatchTClonesArray(newClass.GetClass())) {
               Int_t elemType = element->GetType();
               Bool_t isPrealloc = (elemType == kObjectp) || (elemType == kAnyp) || (elemType == (kObjectp + kOffsetL)) || (elemType == (kAnyp + kOffsetL));
               element->Update(oldClass, newClass.GetClass());
               TVirtualCollectionProxy *cp = newClass->GetCollectionProxy();
               TConvertClonesArrayToProxy *ms = new TConvertClonesArrayToProxy(cp, element->IsaPointer(), isPrealloc);
               element->SetStreamer(ms);

               // When the type is kObject, the TObject::Streamer is used instead
               // of the TStreamerElement's streamer.  So let force the usage
               // of our streamer
               if (element->GetType() == kObject) {
                  element->SetNewType(kAny);
                  element->SetType(kAny);
               }
               if (gDebug > 0) {
                  Warning("BuildOld","element: %s::%s %s has new type %s", GetName(), element->GetTypeName(), element->GetName(), newClass->GetName());
               }
            } else {
               element->SetNewType(-2);
            }
         } else if (oldClass && oldClass->GetCollectionProxy() && newClass->GetCollectionProxy()) {
            {
               TClass *oldFixedClass = FixCollectionV5(GetClass(),oldClass,newClass);
               if (oldFixedClass && oldFixedClass != oldClass) {
                  element->Update(oldClass,oldFixedClass);
                  oldClass = oldFixedClass;
               }
            }
            if (CollectionMatch(oldClass, newClass)) {
               Int_t oldkind = TMath::Abs(TClassEdit::IsSTLCont( oldClass->GetName() ));
               Int_t newkind = TMath::Abs(TClassEdit::IsSTLCont( newClass->GetName() ));

               if ( (oldkind==ROOT::kSTLmap || oldkind==ROOT::kSTLmultimap) &&
                    (newkind!=ROOT::kSTLmap && newkind!=ROOT::kSTLmultimap) ) {

                  Int_t elemType = element->GetType();
                  Bool_t isPrealloc = (elemType == kObjectp) || (elemType == kAnyp) || (elemType == (kObjectp + kOffsetL)) || (elemType == (kAnyp + kOffsetL));

                  TClassStreamer *streamer2 = newClass->GetStreamer();
                  if (streamer2) {
                     TConvertMapToProxy *ms = new TConvertMapToProxy(streamer2, element->IsaPointer(), isPrealloc);
                     if (ms && ms->IsValid()) {
                        element->SetStreamer(ms);
                        switch( element->GetType() ) {
                           //case TStreamerInfo::kSTLvarp:           // Variable size array of STL containers.
                        case TStreamerInfo::kSTLp:                // Pointer to container with no virtual table (stl) and no comment
                        case TStreamerInfo::kSTLp + TStreamerInfo::kOffsetL:     // array of pointers to container with no virtual table (stl) and no comment
                           element->SetNewType(-2);
                           break;
                        case TStreamerInfo::kSTL:             // container with no virtual table (stl) and no comment
                        case TStreamerInfo::kSTL + TStreamerInfo::kOffsetL:  // array of containers with no virtual table (stl) and no comment
                           break;
                        }
                     } else {
                        delete ms;
                     }
                  }
                  element->Update(oldClass, newClass.GetClass());

               } else if ( (newkind==ROOT::kSTLmap || newkind==ROOT::kSTLmultimap) &&
                           (oldkind!=ROOT::kSTLmap && oldkind!=ROOT::kSTLmultimap) ) {
                  element->SetNewType(-2);
               } else {
                  element->Update(oldClass, newClass.GetClass());
               }
               // Is this needed ? : element->SetSTLtype(newelement->GetSTLtype());
               if (gDebug > 0) {
                  Warning("BuildOld","element: %s::%s %s has new type %s", GetName(), element->GetTypeName(), element->GetName(), newClass->GetName());
               }
            } else if (CollectionMatchFloat16(oldClass,newClass)) {
               // Actually nothing to do, since both are the same collection of double in memory.
            } else if (CollectionMatchDouble32(oldClass,newClass)) {
               // Actually nothing to do, since both are the same collection of double in memory.
            } else if (CollectionMatchLong64(oldClass,newClass)) {
               // Not much to do since both are the same collection of 8 bits entities on file.
               element->Update(oldClass, newClass.GetClass());
            } else if (CollectionMatchULong64(oldClass,newClass)) {
               // Not much to do since both are the same collection of 8 bits unsigned entities on file
               element->Update(oldClass, newClass.GetClass());
            } else if (newClass->GetSchemaRules()->HasRuleWithSourceClass( oldClass->GetName() )) {
               //------------------------------------------------------------------------
               // We can convert one type to another (at least for some of the versions).
               //------------------------------------------------------------------------
               element->SetNewClass( newClass );
            } else {
               element->SetNewType(-2);
            }

         } else if(oldClass &&
                   newClass.GetClass() &&
                   newClass->GetSchemaRules() &&
                   newClass->GetSchemaRules()->HasRuleWithSourceClass( oldClass->GetName() ) ) {
            //------------------------------------------------------------------------
            // We can convert one type to another (at least for some of the versions).
            //------------------------------------------------------------------------
            element->SetNewClass( newClass );
         } else {
            element->SetNewType(-2);
         }
         // Humm we still need to make sure we have the same 'type' (pointer, embedded object, array, etc..)
         Bool_t cannotConvert = kFALSE;
         if (element->GetNewType() != -2) {
            if (dm) {
               if (dm->IsaPointer()) {
                  if (strncmp(dm->GetTitle(),"->",2)==0) {
                     // We are fine, nothing to do.
                     if (newClass->IsTObject()) {
                        newType = kObjectp;
                     } else if (newClass->GetCollectionProxy()) {
                        newType = kSTLp;
                     } else {
                        newType = kAnyp;
                     }
                  } else {
                     if (TClass::GetClass(dm->GetTypeName())->IsTObject()) {
                        newType = kObjectP;
                     } else if (newClass->GetCollectionProxy()) {
                        newType = kSTLp;
                     } else {
                        newType = kAnyP;
                     }
                  }
               } else {
                  if (newClass->GetCollectionProxy()) {
                     newType = kSTL;
                  } else if (newClass == TString::Class()) {
                     newType = kTString;
                  } else if (newClass == TObject::Class()) {
                     newType = kTObject;
                  } else if (newClass == TNamed::Class()) {
                     newType = kTNamed;
                  } else if (newClass->IsTObject()) {
                     newType = kObject;
                  } else {
                     newType = kAny;
                  }
               }
               if ((!dm->IsaPointer() || newType==kSTLp) && dm->GetArrayDim() > 0) {
                  newType += kOffsetL;
               }
            } else if (!fClass->IsLoaded()) {
               TStreamerInfo* newInfo = (TStreamerInfo*) fClass->GetStreamerInfos()->At(fClass->GetClassVersion());
               if (newInfo && (newInfo != this)) {
                  TStreamerElement* newElems = (TStreamerElement*) newInfo->GetElements()->FindObject(element->GetName());
                  if (newElems) {
                     newType = newElems->GetType();
                  }
               } else {
                  newType = element->GetType();
               }
            }
            if (element->GetType() == kSTL
                || ((element->GetType() == kObject || element->GetType() == kAny || element->GetType() == kObjectp || element->GetType() == kAnyp)
                    && oldClass == TClonesArray::Class()))
            {
               cannotConvert = (newType != kSTL && newType != kObject && newType != kAny && newType != kSTLp && newType != kObjectp && newType != kAnyp);

            } else if (element->GetType() == kSTLp  || ((element->GetType() == kObjectP || element->GetType() == kAnyP) && oldClass == TClonesArray::Class()) )
            {
               cannotConvert = (newType != kSTL && newType != kObject && newType != kAny && newType != kSTLp && newType != kObjectP && newType != kAnyP);

            } else if (element->GetType() == kSTL + kOffsetL
                || ((element->GetType() == kObject + kOffsetL|| element->GetType() == kAny + kOffsetL|| element->GetType() == kObjectp+ kOffsetL || element->GetType() == kAnyp+ kOffsetL)
                    && oldClass == TClonesArray::Class()))
            {
               cannotConvert = (newType != kSTL + kOffsetL && newType != kObject+ kOffsetL && newType != kAny+ kOffsetL && newType != kSTLp+ kOffsetL && newType != kObjectp+ kOffsetL && newType != kAnyp+ kOffsetL);

            } else if (element->GetType() == kSTLp + kOffsetL || ((element->GetType() == kObjectP+ kOffsetL || element->GetType() == kAnyP+ kOffsetL) && oldClass == TClonesArray::Class()) )
            {
               cannotConvert = (newType != kSTL+ kOffsetL && newType != kObject+ kOffsetL && newType != kAny+ kOffsetL && newType != kSTLp + kOffsetL&& newType != kObjectP+ kOffsetL && newType != kAnyP+ kOffsetL);

            } else if ((element->GetType() == kObjectp || element->GetType() == kAnyp
                 || element->GetType() == kObject || element->GetType() == kAny
                 || element->GetType() == kTObject || element->GetType() == kTNamed || element->GetType() == kTString )) {
               // We had Type* ... ; //-> or Type ...;
               // this is completely compatible with the same and with a embedded object.
               if (newType != -1) {
                  if (newType == kObjectp || newType == kAnyp
                      || newType == kObject || newType == kAny
                      || newType == kTObject || newType == kTNamed || newType == kTString) {
                     // We are fine, no transformation to make
                     element->SetNewType(newType);
                  } else {
                     // We do not support this yet.
                     cannotConvert = kTRUE;
                  }
               } else {
                  // We have no clue
                  cannotConvert = kTRUE;
               }
            } else if (element->GetType() == kObjectP || element->GetType() == kAnyP) {
               if (newType != -1) {
                  if (newType == kObjectP || newType == kAnyP ) {
                     // nothing to do}
                  } else {
                     cannotConvert = kTRUE;
                  }
               } else {
                  // We have no clue
                  cannotConvert = kTRUE;
               }
            }
         }
         if (cannotConvert) {
            element->SetNewType(-2);
            if (gDebug > 0) {
               // coverity[mixed_enums] - All the values of EDataType have the same semantic in EReadWrite
               Info("BuildOld", "element: %s %s::%s has new type: %s/%d", element->GetTypeName(), GetName(), element->GetName(), dm ? dm->GetFullTypeName() : TDataType::GetTypeName((EDataType)newType), newType);
            }
         }
      } else {
         element->SetNewType(-1);
         offset = kMissing;
         element->SetOffset(kMissing);
      }

      if (offset != kMissing && fClass->GetState() <= TClass::kEmulated) {
         // Note the initialization in this case are
         // delayed until __after__ the schema evolution
         // section, just in case the info has changed.

         // The class is NOT known to Cling, i.e. is emulated,
         // and we need to use the calculated offset.

         Int_t asize;
         if (element->GetType() == TStreamerInfo::kSTL &&
             strcmp(element->GetName(),"This") == 0 &&
             strcmp(element->GetTypeName(),GetName()) == 0 &&
             !fClass->GetCollectionProxy()) {
            // Humm .. we are missing the collection Proxy
            // for a proxied (custom) collection ... avoid
            // an infinite recursion and take a wild guess
            asize = sizeof(std::vector<int>);
         } else {
            // Regular case
            asize = element->GetSize();
         }
         // align the non-basic data types (required on alpha and IRIX!!)
         if ((offset % sp) != 0) {
            offset = offset - (offset % sp) + sp;
         }
         element->SetOffset(offset);
         offset += asize;
      }

      if (!wasCompiled && rules) {
         if (rules->HasRuleWithSource( element->GetName(), kTRUE ) ) {

            if (allocClass == 0) {
               infoalloc  = (TStreamerInfo *)Clone(TString::Format("%s@@%d",GetName(),GetOnFileClassVersion()));
               if (!infoalloc) {
                  Error("BuildOld","Unable to create the StreamerInfo for %s.",TString::Format("%s@@%d",GetName(),GetOnFileClassVersion()).Data());
               } else {
                  infoalloc->SetBit(kBuildOldUsed,false);
                  infoalloc->BuildCheck();
                  infoalloc->BuildOld();
                  allocClass = infoalloc->GetClass();
               }
            }

            // Now that we are caching the unconverted element, we do not assign it to the real type even if we could have!
            if (element->GetNewType()>0 /* intentionally not including base class for now */
                && !rules->HasRuleWithTarget( element->GetName(), kTRUE ) ) {

               TStreamerElement *copy = (TStreamerElement*)element->Clone();
               R__TObjArray_InsertBefore( fElements, copy, element );
               next(); // move the cursor passed the insert object.
               copy->SetBit(TStreamerElement::kRepeat);
               element = copy;

               // Warning("BuildOld","%s::%s is not set from the version %d of %s (You must add a rule for it)\n",GetName(), element->GetName(), GetClassVersion(), GetName() );
            } else {
               // If the element is just cached and not repeat, we need to inject an element
               // to insure the writing.
               TStreamerElement *writecopy = (TStreamerElement*)element->Clone();
               R__TObjArray_InsertAfter( fElements, writecopy, element );
               next(); // move the cursor passed the insert object.
               writecopy->SetBit(TStreamerElement::kWrite);
               writecopy->SetNewType( writecopy->GetType() );
               writecopy->SetBit(TStreamerElement::kCache);
               writecopy->SetOffset(infoalloc ? infoalloc->GetOffset(element->GetName()) : 0);
            }
            element->SetBit(TStreamerElement::kCache);
            element->SetNewType( element->GetType() );
            element->SetOffset(infoalloc ? infoalloc->GetOffset(element->GetName()) : 0);
         } else if (rules->HasRuleWithTarget( element->GetName(), kTRUE ) ) {
            // The data member exist in the onfile StreamerInfo and there is a rule
            // that has the same member 'only' has a target ... so this means we are
            // asked to ignore the input data ...
            if (element->GetType() == kCounter) {
               // If the element is a counter, we will need its value to read
               // other data member, so let's do so (by not disabling it) even
               // if the value will be over-written by a rule.
            } else {
               element->SetOffset(kMissing);
            }
         }
      } else if (rules && rules->HasRuleWithTarget( element->GetName(), kTRUE ) ) {
         // The data member exist in the onfile StreamerInfo and there is a rule
         // that has the same member 'only' has a target ... so this means we are
         // asked to ignore the input data ...
         if (element->GetType() == kCounter) {
            // If the element is a counter, we will need its value to read
            // other data member, so let's do so (by not disabling it) even
            // if the value will be over-written by a rule.
         } else {
            element->SetOffset(kMissing);
         }
      }

      if (element->GetNewType() == -2) {
         Warning("BuildOld", "Cannot convert %s::%s from type:%s to type:%s, skip element", GetName(), element->GetName(), element->GetTypeName(), newClass ? newClass->GetName() : (dm ? dm->GetFullTypeName() : "unknown") );
      }
   }

   // If we get here, this means that there no data member after the last base class
   // (or no base class at all).
   if (shouldHaveInfoLoc && fNVirtualInfoLoc==0) {
      fNVirtualInfoLoc = 1;
      fVirtualInfoLoc = new ULong_t[1]; // To allow for a single delete statement.
      fVirtualInfoLoc[0] = offset;
      offset += sizeof(TStreamerInfo*);
   }

   // change order , move "bazes" to the end. Workaround old bug
   if ((fOldVersion <= 2) && nBaze) {
      SetBit(kRecovered);
      TObjArray& arr = *fElements;
      TObjArray tai(nBaze);
      int narr = arr.GetLast() + 1;
      int iel;
      int jel = 0;
      int kel = 0;
      for (iel = 0; iel < narr; ++iel) {
         element = (TStreamerElement*) arr[iel];
         if (element->IsBase() && (element->IsA() != TStreamerBase::Class())) {
            tai[kel++] = element;
         } else {
            arr[jel++] = element;
         }
      }
      for (kel = 0; jel < narr;) {
         arr[jel++] = tai[kel++];
      }
   }

   // Now add artificial TStreamerElement (i.e. rules that creates new members or set transient members).
   if (!wasCompiled) InsertArtificialElements(rules);

   if (!wasCompiled && allocClass) {

      TStreamerElement *el = new TStreamerArtificial("@@alloc","", 0, TStreamerInfo::kCacheNew, allocClass->GetName());
      R__TObjArray_InsertAt( fElements, el, 0 );

      el = new TStreamerArtificial("@@dealloc","", 0, TStreamerInfo::kCacheDelete, allocClass->GetName());
      fElements->Add( el );
   }

   Compile();
   delete rules;
}

//______________________________________________________________________________
void TStreamerInfo::Clear(Option_t *option)
{
   // If opt cointains 'built', reset this StreamerInfo as if Build or BuildOld
   // was never called on it (usefull to force their re-running).

   TString opt = option;
   opt.ToLower();

   if (opt.Contains("build")) {
      R__LOCKGUARD2(gInterpreterMutex);

      delete [] fComp;     fComp    = 0;
      delete [] fCompFull; fCompFull= 0;
      delete [] fCompOpt;  fCompOpt = 0;
      fNdata = 0;
      fNfulldata = 0;
      fNslots= 0;
      fSize = 0;
      ResetIsCompiled();
      ResetBit(kBuildOldUsed);

      if (fReadObjectWise) fReadObjectWise->fActions.clear();
      if (fReadMemberWise) fReadMemberWise->fActions.clear();
      if (fReadMemberWiseVecPtr) fReadMemberWiseVecPtr->fActions.clear();
      if (fWriteObjectWise) fWriteObjectWise->fActions.clear();
      if (fWriteMemberWise) fWriteMemberWise->fActions.clear();
      if (fWriteMemberWiseVecPtr) fWriteMemberWiseVecPtr->fActions.clear();
   }
}

namespace {
   // TMemberInfo
   // Local helper class to be able to compare data member represened by
   // 2 distinct TStreamerInfos
   class TMemberInfo {
   public:
      TClass  *fParent;
      TString fName;
      TString fClassName;
      TString fComment;
      Int_t   fDataType;

      TMemberInfo(TClass *parent) : fParent(parent) {};

      void SetDataType(Int_t datatype) {
         fDataType = datatype;
      }

      void SetName(const char *name) {
         fName = name;
      }
      void SetClassName(const char *name) {
         fClassName = TClassEdit::ResolveTypedef(TClassEdit::ShortType( name, TClassEdit::kDropStlDefault | TClassEdit::kDropStd ).c_str(),kTRUE);
      }
      void SetComment(const char *title) {
         const char *left = strstr(title,"[");
         if (left) {
            const char *right = strstr(left,"]");
            if (right) {
               ++left;
               fComment.Append(left,right-left);
            }
         }
      }
      void Clear() {
         fName.Clear();
         fClassName.Clear();
         fComment.Clear();
      }
      /* Hide this not yet used implementation to suppress warnings message
       from icc 11
      Bool_t operator==(const TMemberInfo &other) {
         return fName==other.fName
            && fClassName == other.fClassName
            && fComment == other.fComment;
      }
       */
      Bool_t operator!=(const TMemberInfo &other) {
         if (fName != other.fName) return kTRUE;
         if (fDataType < TStreamerInfo::kObject) {
            // For simple type, let compare the data type
            if (fDataType != other.fDataType) {
               if ( (fDataType == 4 && other.fDataType == 16)
                    || (fDataType == 16 && other.fDataType == 4) ) {
                  // long and 'long long' have the same  file format
               } else if ( (fDataType == 14 && other.fDataType == 17)
                           || (fDataType == 17 && other.fDataType == 14) ) {
                  // unsigned long and 'unsigned long long' have the same  file format
               } else if ( (fDataType == 3 && other.fDataType == 6)
                          ||(fDataType == 6 && other.fDataType == 3) ){
                  // Int_t and kCounter.  As the switch from Int_t (3) to
                  // kCounter (6) might be triggered by a derived class using
                  // the field as an array size, the class itself has no
                  // control on what the field type really use.
               } else {
                  return kTRUE;
               }
            }
         } else if (fClassName != other.fClassName) {
            if ( (fClassName == "long" && (other.fClassName == "long long" || other.fClassName == "Long64_t"))
                  || ( (fClassName == "long long" || fClassName == "Long64_t") && other.fClassName == "long") ) {
               // This is okay both have the same on file format.
            } else if ( (fClassName == "unsigned long" && (other.fClassName == "unsigned long long" || other.fClassName == "ULong64_t"))
                       || ( (fClassName == "unsigned long long" || fClassName == "ULong64_t") && other.fClassName == "unsigned long") ) {
               // This is okay both have the same on file format.
            } else if (TClassEdit::IsSTLCont(fClassName)) {
               TString name = TClassEdit::ShortType( fClassName, TClassEdit::kDropStlDefault );
               TString othername = TClassEdit::ShortType( other.fClassName, TClassEdit::kDropStlDefault );
               if (name != othername) {
                  TClass *cl = TClass::GetClass(name);
                  TClass *otherCl = TClass::GetClass(othername);
                  if (!CollectionMatch(cl,otherCl)) {
                     TClass *oldFixedClass = FixCollectionV5(fParent,cl,otherCl);
                     if (!oldFixedClass || !CollectionMatch(oldFixedClass,otherCl)) {
                        return kTRUE;
                     }
                  }
               }
            } else {
               return kTRUE;
            }
         }
         return fComment != other.fComment;
      }
   };
}

//______________________________________________________________________________
void TStreamerInfo::CallShowMembers(const void* obj, TMemberInspector &insp, Bool_t isTransient) const
{
   // Emulated a call ShowMembers() on the obj of this class type, passing insp and parent.

   TIter next(fElements);
   TStreamerElement* element = (TStreamerElement*) next();

   TString elementName;

   for (; element; element = (TStreamerElement*) next()) {

      // Skip elements which have not been allocated memory.
      if (element->GetOffset() == kMissing) {
         continue;
      }

      char* eaddr = ((char*)obj) + element->GetOffset();

      if (element->IsBase()) {
         // Nothing to do this round.
      } else if (element->IsaPointer()) {
         elementName.Form("*%s",element->GetFullName());
         insp.Inspect(fClass, insp.GetParent(), elementName.Data(), eaddr, isTransient);
      } else {
         insp.Inspect(fClass, insp.GetParent(), element->GetFullName(), eaddr, isTransient);
         Int_t etype = element->GetType();
         switch(etype) {
            case kObject:
            case kAny:
            case kTObject:
            case kTString:
            case kTNamed:
            case kSTL:
            {
               TClass *ecl = element->GetClassPointer();
               if (ecl && (fClass!=ecl /* This happens 'artificially for stl container see the use of "This" */)) {
                  insp.InspectMember(ecl, eaddr, TString(element->GetName()) + ".", isTransient);
               }
               break;
            }
         } // switch(etype)
      } // if IsaPointer()
   } // Loop over elements

   // And now do the base classes
   next.Reset();
   element = (TStreamerElement*) next();
   for (; element; element = (TStreamerElement*) next()) {
      if (element->IsBase()) {
         // Skip elements which have not been allocated memory.
         if (element->GetOffset() == kMissing) {
            continue;
         }

         char* eaddr = ((char*)obj) + element->GetOffset();

         TClass *ecl = element->GetClassPointer();
         if (ecl) {
            ecl->CallShowMembers(eaddr, insp, isTransient);
         }
      } // If is a abse
   } // Loop over elements
}

//______________________________________________________________________________
TObject *TStreamerInfo::Clone(const char *newname) const
{
   // Make a clone of an object using the Streamer facility.
   // If newname is specified, this will be the name of the new object.

   TStreamerInfo *newinfo = (TStreamerInfo*)TNamed::Clone(newname);
   if (newname && newname[0] && fName != newname) {
      TObjArray *newelems = newinfo->GetElements();
      Int_t ndata = newelems->GetEntries();
      for(Int_t i = 0; i < ndata; ++i) {
         TObject *element = newelems->UncheckedAt(i);
         if (element->IsA() == TStreamerLoop::Class()) {
            TStreamerLoop *eloop = (TStreamerLoop*)element;
            if (fName == eloop->GetCountClass()) {
               eloop->SetCountClass(newname);
               eloop->Init();
            }
         } else if (element->IsA() == TStreamerBasicPointer::Class()) {
            TStreamerBasicPointer *eptr = (TStreamerBasicPointer*)element;
            if (fName == eptr->GetCountClass()) {
               eptr->SetCountClass(newname);
               eptr->Init();
            }
         }
      }
   }
   return newinfo;
}

//______________________________________________________________________________
Bool_t TStreamerInfo::CompareContent(TClass *cl, TVirtualStreamerInfo *info, Bool_t warn, Bool_t complete, TFile *file)
{
   // Return True if the current StreamerInfo in cl or info is equivalent to this TStreamerInfo.
   // 'Equivalent' means the same number of persistent data member which the same actual C++ type and
   // the same name.
   // if 'warn' is true, Warning message are printed to explicit the differences.
   // if 'complete' is false, stop at the first error, otherwise continue until all members have been checked.

   Bool_t result = kTRUE;
   R__ASSERT( (cl==0 || info==0) && (cl!=0 || info!=0) /* must compare to only one thhing! */);

   TString name;
   TString type;
   TStreamerElement *el;
   TStreamerElement *infoel = 0;

   TIter next(GetElements());
   TIter infonext((TList*)0);
   TIter basenext((TList*)0);
   TIter membernext((TList*)0);
   if (info) {
      infonext = info->GetElements();
   }
   if (cl) {
      TList *tlb = cl->GetListOfBases();
      if (tlb) {   // Loop over bases
         basenext = tlb;
      }
      tlb = cl->GetListOfDataMembers();
      if (tlb) {
         membernext = tlb;
      }
   }

   // First let's compare base classes
   Bool_t done = kFALSE;
   TString localClass;
   TString otherClass;
   while(!done) {
      localClass.Clear();
      otherClass.Clear();
      el = (TStreamerElement*)next();
      if (el && el->IsBase()) {
         localClass = el->GetName();
      } else {
         el = 0;
      }
      if (cl) {
         TBaseClass *tbc = (TBaseClass*)basenext();
         if (tbc) {
            otherClass = tbc->GetName();
         } else if (el==0) {
            done = kTRUE;
            break;
         }
      } else {
         infoel = (TStreamerElement*)infonext();
         if (infoel && infoel->IsBase()) {
            otherClass = infoel->GetName();
         } else if (el==0) {
            done = kTRUE;
            break;
         }
      }
      if (TClassEdit::IsSTLCont(localClass)) {
         localClass = TClassEdit::ShortType( localClass, TClassEdit::kDropStlDefault );
         otherClass = TClassEdit::ShortType( otherClass, TClassEdit::kDropStlDefault );
      }
      // Need to normalize the name
      if (localClass != otherClass) {
         if (warn) {
            if (el==0) {
               Warning("CompareContent",
                       "The in-memory layout version %d for class '%s' has a base class (%s) that the on-file layout version %d does not have.",
                       GetClassVersion(), GetName(), otherClass.Data(), GetClassVersion());
            } else if (otherClass.Length()==0) {
               Warning("CompareContent",
                       "The on-file layout version %d for class '%s'  has a base class (%s) that the in-memory layout version %d does not have",
                       GetClassVersion(), GetName(), localClass.Data(), GetClassVersion());
            } else {
               Warning("CompareContent",
                       "One base class of the on-file layout version %d and of the in memory layout version %d for '%s' is different: '%s' vs '%s'",
                       GetClassVersion(), GetClassVersion(), GetName(), localClass.Data(), otherClass.Data());
            }
         }
         if (!complete) return kFALSE;
         result = result && kFALSE;
      }
      if (cl) {
         TStreamerBase *localBase = dynamic_cast<TStreamerBase*>(el);
         if (!localBase) continue;
         // We already have localBaseClass == otherBaseClass
         TClass *otherBaseClass = localBase->GetClassPointer();
         if (!otherBaseClass) continue;
         if (otherBaseClass->IsVersioned() && localBase->GetBaseVersion() != otherBaseClass->GetClassVersion()) {
            TString msg;
            msg.Form("   The StreamerInfo of class %s read from %s%s\n"
                     "   has the same version (=%d) as the active class but a different checksum.\n"
                     "   You should update the version to ClassDef(%s,%d).\n"
                     "   The objects on this file might not be readable because:\n"
                     "   The in-memory layout version %d for class '%s' has a base class (%s) with version %d but the on-file layout version %d recorded the version number %d for this base class (%s).",
                     GetName(), file ? "file " : "", file ? file->GetName() : "", fClassVersion, GetName(), fClassVersion + 1,
                     GetClassVersion(), GetName(), otherClass.Data(), otherBaseClass->GetClassVersion(),
                     GetClassVersion(), localBase->GetBaseVersion(), localClass.Data());
            TStreamerBase *otherBase = (TStreamerBase*)cl->GetStreamerInfo()->GetElements()->FindObject(otherClass);
            otherBase->SetErrorMessage(msg);

         } else if (!otherBaseClass->IsVersioned() && localBase->GetBaseCheckSum() != otherBaseClass->GetCheckSum()) {
            TVirtualStreamerInfo *localBaseInfo = otherBaseClass->FindStreamerInfo(localBase->GetBaseCheckSum());
            if (localBaseInfo->CompareContent(otherBaseClass,0,kFALSE,kFALSE,file) ) {
               // They are equivalent, no problem.
               continue;
            }
            TString msg;
            msg.Form("   The StreamerInfo of class %s read from %s%s\n"
                     "   has the same version (=%d) as the active class but a different checksum.\n"
                     "   You should update the version to ClassDef(%s,%d).\n"
                     "   The objects on this file might not be readable because:\n"
                     "   The in-memory layout version %d for class '%s' has a base class (%s) with checksum %x but the on-file layout version %d recorded the checksum value %x for this base class (%s).",
                     GetName(), file ? "file " : "", file ? file->GetName() : "", fClassVersion, GetName(), fClassVersion + 1,
                     GetClassVersion(), GetName(), otherClass.Data(), otherBaseClass->GetCheckSum(),
                     GetClassVersion(), localBase->GetBaseCheckSum(), localClass.Data());
            TStreamerBase *otherBase = (TStreamerBase*)cl->GetStreamerInfo()->GetElements()->FindObject(otherClass);
            otherBase->SetErrorMessage(msg);
         }
      } else {
         TStreamerBase *localBase = dynamic_cast<TStreamerBase*>(el);
         TStreamerBase *otherBase = dynamic_cast<TStreamerBase*>(infoel);
         if (!localBase || !otherBase) continue;

         // We already have localBaseClass == otherBaseClass
         TClass *otherBaseClass = localBase->GetClassPointer();
         if (otherBaseClass->IsVersioned() && localBase->GetBaseVersion() != otherBase->GetBaseVersion()) {
            TString msg;
            msg.Form("   The StreamerInfo of class %s read from %s%s\n"
                     "   has the same version (=%d) as the active class but a different checksum.\n"
                     "   You should update the version to ClassDef(%s,%d).\n"
                     "   The objects on this file might not be readable because:\n"
                     "   The in-memory layout version %d for class '%s' has a base class (%s) with version %d but the on-file layout version %d recorded the version number %d for this base class (%s).",
                     GetName(), file ? "file " : "", file ? file->GetName() : "", fClassVersion, GetName(), fClassVersion + 1,
                     GetClassVersion(), GetName(), otherClass.Data(), otherBase->GetBaseVersion(),
                     GetClassVersion(), localBase->GetBaseVersion(), localClass.Data());
            otherBase->SetErrorMessage(msg);

         } else if (!otherBaseClass->IsVersioned() && localBase->GetBaseCheckSum() != otherBase->GetBaseCheckSum())
         {
            TVirtualStreamerInfo *localBaseInfo = otherBaseClass->FindStreamerInfo(localBase->GetBaseCheckSum());
            TVirtualStreamerInfo *otherBaseInfo = otherBaseClass->FindStreamerInfo(otherBase->GetBaseCheckSum());
            if (localBaseInfo == otherBaseInfo ||
                localBaseInfo->CompareContent(0,otherBaseInfo,kFALSE,kFALSE,file) ) {
               // They are equivalent, no problem.
               continue;
            }
            TString msg;
            msg.Form("   The StreamerInfo of class %s read from %s%s\n"
                     "   has the same version (=%d) as the active class but a different checksum.\n"
                     "   You should update the version to ClassDef(%s,%d).\n"
                     "   The objects on this file might not be readable because:\n"
                     "   The in-memory layout version %d for class '%s' has a base class (%s) with checksum %x but the on-file layout version %d recorded the checksum value %x for this base class (%s).",
                     GetName(), file ? "file " : "", file ? file->GetName() : "", fClassVersion, GetName(), fClassVersion + 1,
                     GetClassVersion(), GetName(), otherClass.Data(), otherBase->GetBaseCheckSum(),
                     GetClassVersion(), localBase->GetBaseCheckSum(), localClass.Data());
            otherBase->SetErrorMessage(msg);
         }
      }
   }
   if (!result && !complete) {
      return result;
   }
   // Next the datamembers
   done = kFALSE;
   next.Reset();
   infonext.Reset();

   TMemberInfo local(GetClass());
   TMemberInfo other(cl ? cl : info->GetClass());
   UInt_t idx = 0;
   while(!done) {
      local.Clear();
      other.Clear();
      el = (TStreamerElement*)next();
      while (el && (el->IsBase() || el->IsA() == TStreamerArtificial::Class())) {
         el = (TStreamerElement*)next();
         ++idx;
      }
      if (el) {
         local.SetName( el->GetName() );
         local.SetClassName( el->GetTypeName() );
         local.SetComment( el->GetTitle() );
         local.SetDataType( el->GetType() );
      }
      if (cl) {
         TDataMember *tdm = (TDataMember*)membernext();
         while(tdm && ( (!tdm->IsPersistent()) || (tdm->Property()&kIsStatic) || (el && local.fName != tdm->GetName()) )) {
            tdm = (TDataMember*)membernext();
         }
         if (tdm) {
            other.SetName( tdm->GetName() );
            other.SetClassName( tdm->GetTrueTypeName() );
            other.SetComment( tdm->GetTitle() );
            if (tdm->GetDataType()) {
               // Need to update the type for arrays.
               if (tdm->IsaPointer()) {
                  if (tdm->GetDataType()->GetType() == TVirtualStreamerInfo::kChar && !tdm->GetArrayDim() && tdm->GetArrayIndex()[0]==0) {
                     other.SetDataType( TVirtualStreamerInfo::kCharStar );
                  } else {
                     other.SetDataType( tdm->GetDataType()->GetType() + TVirtualStreamerInfo::kOffsetP);
                  }
               } else {
                  if (tdm->GetArrayDim()) {
                     other.SetDataType( tdm->GetDataType()->GetType() + TVirtualStreamerInfo::kOffsetL);
                  } else {
                     other.SetDataType( tdm->GetDataType()->GetType() );
                  }
               }
            }
         } else if (el==0) {
            done = kTRUE;
            break;
         }
      } else {
         infoel = (TStreamerElement*)infonext();
         while (infoel && (infoel->IsBase() || infoel->IsA() == TStreamerArtificial::Class())) {
            infoel = (TStreamerElement*)infonext();
         }
         if (infoel) {
            other.SetName( infoel->GetName() );
            other.SetClassName( infoel->GetTypeName() );
            other.SetComment( infoel->GetTitle() );
            other.SetDataType( infoel->GetType() );
         } else if (el==0) {
            done = kTRUE;
            break;
         }
      }
      if (local!=other) {
         if (warn) {
            if (!el) {
               Warning("CompareContent","The following data member of\nthe in-memory layout version %d of class '%s' is missing from \nthe on-file layout version %d:\n"
                       "   %s %s; //%s"
                       ,GetClassVersion(), GetName(), GetClassVersion()
                       ,other.fClassName.Data(),other.fName.Data(),other.fComment.Data());

            } else if (other.fName.Length()==0) {
               Warning("CompareContent","The following data member of\nthe in-memory layout version %d of class '%s' is missing from \nthe on-file layout version %d:\n"
                       "   %s %s; //%s"
                       ,GetClassVersion(), GetName(), GetClassVersion()
                       ,local.fClassName.Data(),local.fName.Data(),local.fComment.Data());
            } else {
               Warning("CompareContent","The following data member of\nthe on-file layout version %d of class '%s' differs from \nthe in-memory layout version %d:\n"
                       "   %s %s; //%s\n"
                       "vs\n"
                       "   %s %s; //%s"
                       ,GetClassVersion(), GetName(), GetClassVersion()
                       ,local.fClassName.Data(),local.fName.Data(),local.fComment.Data()
                       ,other.fClassName.Data(),other.fName.Data(),other.fComment.Data());
            }
         }
         result = result && kFALSE;
         if (!complete) return result;
      }
      ++idx;
   }
   return result;
}


//______________________________________________________________________________
void TStreamerInfo::ComputeSize()
{
   // Compute total size of all persistent elements of the class

   TStreamerElement *element = (TStreamerElement*)fElements->Last();
   //faster and more precise to use last element offset +size
   //on 64 bit machines, offset may be forced to be a multiple of 8 bytes
   fSize = element ? element->GetOffset() + element->GetSize() : 0;
   if (fNVirtualInfoLoc > 0 && (fVirtualInfoLoc[0]+sizeof(TStreamerInfo*)) >= (ULong_t)fSize) {
      fSize = fVirtualInfoLoc[0] + sizeof(TStreamerInfo*);
   }
}

//______________________________________________________________________________
void TStreamerInfo::ForceWriteInfo(TFile* file, Bool_t force)
{
   // -- Recursively mark streamer infos for writing to a file.
   //
   // Will force this TStreamerInfo to the file and also
   // all the dependencies.
   //
   // If argument force > 0 the loop on class dependencies is forced.
   //
   // This function is called when streaming a class that contains
   // a null pointer. In this case, the TStreamerInfo for the class
   // with the null pointer must be written to the file and also all
   // the TStreamerInfo of all the classes referenced by the class.
   //
   //--
   // We must be given a file to write to.
   if (!file) {
      return;
   }
   // Get the given file's list of streamer infos marked for writing.
   TArrayC* cindex = file->GetClassIndex();
   //the test below testing fArray[fNumber]>1 is to avoid a recursivity
   //problem in some cases like:
   //        class aProblemChild: public TNamed {
   //        aProblemChild *canBeNull;
   //        };
   if ( // -- Done if already marked, and we are not forcing, or forcing is blocked.
      (cindex->fArray[fNumber] && !force) || // Streamer info is already marked, and not forcing, or
      (cindex->fArray[fNumber] > 1) // == 2 means ignore forcing to prevent infinite recursion.
   ) {
      return;
   }
   // We do not want to write streamer info to the file
   // for std::string.
   static TClassRef string_classref("string");
   if (fClass == string_classref) { // We are std::string.
      return;
   }
   // We do not want to write streamer info to the file
   // for STL containers.
   if (fClass==0) {
      // Build or BuildCheck has not been called yet.
      // Let's use another means of checking.
      if (fElements && fElements->GetEntries()==1 && strcmp("This",fElements->UncheckedAt(0)->GetName())==0) {
         // We are an STL collection.
         return;
      }
   } else if (fClass->GetCollectionProxy()) { // We are an STL collection.
      return;
   }
   // Mark ourselves for output, and block
   // forcing to prevent infinite recursion.
   cindex->fArray[fNumber] = 2;
   // Signal the file that the marked streamer info list has changed.
   cindex->fArray[0] = 1;
   // Recursively mark the streamer infos for
   // all of our elements.
   TIter next(fElements);
   TStreamerElement* element = (TStreamerElement*) next();
   for (; element; element = (TStreamerElement*) next()) {
      if (element->IsTransient()) continue;
      TClass* cl = element->GetClassPointer();
      if (cl) {
         TVirtualStreamerInfo* si = 0;
         if (cl->Property() & kIsAbstract) {
            // If the class of the element is abstract, register the
            // TStreamerInfo only if it has already been built.
            // Otherwise call cl->GetStreamerInfo() would generate an
            // incorrect StreamerInfo.
            si = cl->GetCurrentStreamerInfo();
         } else {
            si = cl->GetStreamerInfo();
         }
         if (si) {
            si->ForceWriteInfo(file, force);
         }
      }
   }
}

//______________________________________________________________________________
TClass *TStreamerInfo::GetActualClass(const void *obj) const
{
   // Assuming that obj points to (the part of) an object that is of the
   // type described by this streamerInfo, return the actual type of the
   // object (i.e. the type described by this streamerInfo is a base class
   // of the actual type of the object.
   // This routine should only be called if the class decribed by this
   // StreamerInfo is 'emulated'.

   R__ASSERT(!fClass->IsLoaded());

   if (fNVirtualInfoLoc != 0) {
      TStreamerInfo *allocator = *(TStreamerInfo**)( (const char*)obj + fVirtualInfoLoc[0] );
      if (allocator) return allocator->GetClass();
   }
   return (TClass*)fClass;
}

//______________________________________________________________________________
Bool_t TStreamerInfo::MatchLegacyCheckSum(UInt_t checksum) const
{
   // Return true if the checksum passed as argument is one of the checksum
   // value produced by the older checksum calulcation algorithm.

   for(UInt_t i = 1; i < TClass::kLatestCheckSum; ++i) {
      if ( checksum == GetCheckSum( (TClass::ECheckSum) i) ) return kTRUE;
   }
   return kFALSE;
}

//______________________________________________________________________________
UInt_t TStreamerInfo::GetCheckSum(TClass::ECheckSum code) const
{
   // Recalculate the checksum of this TStreamerInfo based on its code.
   //
   // 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.
   // Original algorithm from Victor Perevovchikov (perev@bnl.gov).
   //
   // The valid range of code is determined by ECheckSum
   //
   // kNoEnum:  data members of type enum are not counted in the checksum
   // kNoRange: return the checksum of data members and base classes, not including the ranges and array size found in comments.
   // kWithTypeDef: use the sugared type name in the calculation.
   //
   // 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.

   // kCurrentCheckSum (0) should be kept for backward compatibility, to be
   // able to use the inequality checks, we need to set the code to the largest
   // value.
   if (code == TClass::kCurrentCheckSum) code = TClass::kLatestCheckSum;

   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];

   TIter next(GetElements());
   TStreamerElement *el;
   while ( (el=(TStreamerElement*)next()) && !fClass->GetCollectionProxy()) { // loop over bases if not a proxied collection
      if (el->IsBase()) {
         name = el->GetName();
         il = name.Length();
         for (int i=0; i<il; i++) id = id*3+name[i];
         if (code > TClass::kNoBaseCheckSum && el->IsA() == TStreamerBase::Class()) {
            TStreamerBase *base = (TStreamerBase*)el;
            id = id*3 + base->GetBaseCheckSum();
         }
      }
   } /* End of Base Loop */

   next.Reset();
   while ( (el=(TStreamerElement*)next()) ) {
      if (el->IsBase()) continue;

      // humm can we tell if a TStreamerElement is an enum?
      // Maybe something like:
      Bool_t isenum = kFALSE;
      if ( el->GetType()==3 && gROOT->GetType(el->GetTypeName())==0) {
         // If the type is not an enum but a typedef to int then
         // el->GetTypeName() should be return 'int'
         isenum = kTRUE;
      }
      if ( (code > TClass::kNoEnum) && isenum) id = id*3 + 1;

      name = el->GetName();  il = name.Length();

      int i;
      for (i=0; i<il; i++) id = id*3+name[i];

      if (code == TClass::kReflex || code == TClass::kReflexNoComment) {
         // With TClass::kReflexV5 we do not want the Long64 in the name
         // nor any typedef.
         type = TClassEdit::ResolveTypedef(el->GetTypeName(),kTRUE);

      } else if (code <= TClass::kWithTypeDef) {
         // humm ... In the streamerInfo we only have the desugared/normalized
         // names, so we are unable to calculate the name with typedefs ...
         // except for the case of the ROOT typedef (Int_t, etc.) which are
         // kept by TClassEdit::ResolveTypedef(typeName) but not by TCling's
         // normalization ...
         //
         type = el->GetTypeName();
      } else {
         type = TClassEdit::GetLong64_Name(TClassEdit::ResolveTypedef(el->GetTypeName(),kTRUE));
      }
      if (TClassEdit::IsSTLCont(type)) {
         type = TClassEdit::ShortType( type, TClassEdit::kDropStlDefault | TClassEdit::kLong64 );
      }
      if (code == TClass::kReflex || code == TClass::kReflexNoComment) {
         type.ReplaceAll("ULong64_t","unsigned long long");
         type.ReplaceAll("Long64_t","long long");
         type.ReplaceAll("signed char","char");
         type.ReplaceAll("<signed char","<char");
         type.ReplaceAll(",signed char",",char");
         if (type=="signed char") type = "char";
      }

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

      int dim = el->GetArrayDim();
      if (dim) {
         for (i=0;i<dim;i++) id = id*3+el->GetMaxIndex(i);
      }


      if (code > TClass::kNoRange) {
         const char *left;
         if (code > TClass::kNoRangeCheck)
            left = TVirtualStreamerInfo::GetElementCounterStart(el->GetTitle());
         else
            left = strstr(el->GetTitle(),"[");
         if (left) {
            const char *right = strstr(left,"]");
            if (right) {
               ++left;
               while (left != right) {
                  id = id*3 + *left;
                  ++left;
               }
            }
         }
      }
   }
   return id;
}

//______________________________________________________________________________
static void R__WriteConstructorBody(FILE *file, TIter &next)
{
   TStreamerElement *element = 0;
   next.Reset();
   while ((element = (TStreamerElement*)next())) {
      if (element->GetType() == TVirtualStreamerInfo::kObjectp || element->GetType() == TVirtualStreamerInfo::kObjectP ||
          element->GetType() == TVirtualStreamerInfo::kAnyp || element->GetType() == TVirtualStreamerInfo::kAnyP ||
          element->GetType() == TVirtualStreamerInfo::kCharStar || element->GetType() == TVirtualStreamerInfo::kSTLp ||
          element->GetType() == TVirtualStreamerInfo::kStreamLoop) {
         if(element->GetArrayLength() <= 1) {
            fprintf(file,"   %s = 0;\n",element->GetName());
         } else {
            fprintf(file,"   memset(%s,0,%d);\n",element->GetName(),element->GetSize());
         }
      }
      if (TVirtualStreamerInfo::kOffsetP <= element->GetType() && element->GetType() < TVirtualStreamerInfo::kObject ) {
         fprintf(file,"   %s = 0;\n",element->GetName());
      }
   }
}

//______________________________________________________________________________
static void R__WriteMoveConstructorBody(FILE *file, const TString &protoname, TIter &next)
{
   // Write down the body of the 'move' constructor.

   TStreamerElement *element = 0;
   next.Reset();
   Bool_t atstart = kTRUE;
   while ((element = (TStreamerElement*)next())) {
      if (element->IsBase()) {
         if (atstart) { fprintf(file,"   : "); atstart = kFALSE; }
         else fprintf(file,"   , ");
         fprintf(file, "%s(const_cast<%s &>( rhs ))\n", element->GetName(),protoname.Data());
      } else {
         if (element->GetArrayLength() <= 1) {
            if (atstart) { fprintf(file,"   : "); atstart = kFALSE; }
            else fprintf(file,"   , ");
            fprintf(file, "%s(const_cast<%s &>( rhs ).%s)\n",element->GetName(),protoname.Data(),element->GetName());
         }
      }
   }
   fprintf(file,"{\n");
   fprintf(file,"   // This is NOT a copy constructor. This is actually a move constructor (for stl container's sake).\n");
   fprintf(file,"   // Use at your own risk!\n");
   fprintf(file,"   (void)rhs; // avoid warning about unused parameter\n");
   next.Reset();
   Bool_t defMod = kFALSE;
   while ((element = (TStreamerElement*)next())) {
      if (element->GetType() == TVirtualStreamerInfo::kObjectp || element->GetType() == TVirtualStreamerInfo::kObjectP||
          element->GetType() == TVirtualStreamerInfo::kAnyp || element->GetType() == TVirtualStreamerInfo::kAnyP
          || element->GetType() == TVirtualStreamerInfo::kAnyPnoVT)
      {
         if (!defMod) { fprintf(file,"   %s &modrhs = const_cast<%s &>( rhs );\n",protoname.Data(),protoname.Data()); defMod = kTRUE; };
         const char *ename = element->GetName();
         const char *colon2 = strstr(ename,"::");
         if (colon2) ename = colon2+2;
         if(element->GetArrayLength() <= 1) {
            fprintf(file,"   modrhs.%s = 0;\n",ename);
         } else {
            fprintf(file,"   memset(modrhs.%s,0,%d);\n",ename,element->GetSize());
         }
      } else {
         const char *ename = element->GetName();
         if (element->GetType() == kCharStar) {
            if (!defMod) {
               fprintf(file,"   %s &modrhs = const_cast<%s &>( rhs );\n",protoname.Data(),protoname.Data()); defMod = kTRUE;
            };
            fprintf(file,"   modrhs.%s = 0;\n",ename);
         } else if (TVirtualStreamerInfo::kOffsetP <= element->GetType() && element->GetType() < TVirtualStreamerInfo::kObject ) {
            if (!defMod) {
               fprintf(file,"   %s &modrhs = const_cast<%s &>( rhs );\n",protoname.Data(),protoname.Data()); defMod = kTRUE;
            };
            fprintf(file,"   modrhs.%s = 0;\n",ename);
         } else if (element->GetArrayLength() > 1) {
            // FIXME: Need to add support for variable length array.
            if (element->GetArrayDim() == 1) {
               fprintf(file,"   for (Int_t i=0;i<%d;i++) %s[i] = rhs.%s[i];\n",element->GetArrayLength(),ename,ename);
            } else if (element->GetArrayDim() >= 2) {
               fprintf(file,"   for (Int_t i=0;i<%d;i++) (&(%s",element->GetArrayLength(),ename);
               for (Int_t d = 0; d < element->GetArrayDim(); ++d) {
                  fprintf(file,"[0]");
               }
               fprintf(file,"))[i] = (&(rhs.%s",ename);
               for (Int_t d = 0; d < element->GetArrayDim(); ++d) {
                  fprintf(file,"[0]");
               }
               fprintf(file,"))[i];\n");
            }
         } else if (element->GetType() == TVirtualStreamerInfo::kSTLp) {
            if (!defMod) { fprintf(file,"   %s &modrhs = const_cast<%s &>( rhs );\n",protoname.Data(),protoname.Data()); defMod = kTRUE; };
            fprintf(file,"   modrhs.%s = 0;\n",ename);
         } else if (element->GetType() == TVirtualStreamerInfo::kSTL) {
            if (!defMod) {
               fprintf(file,"   %s &modrhs = const_cast<%s &>( rhs );\n",protoname.Data(),protoname.Data()); defMod = kTRUE;
            }
            if (element->IsBase()) {
               fprintf(file,"   modrhs.clear();\n");
            } else {
               fprintf(file,"   modrhs.%s.clear();\n",ename);
            }
         }
      }
   }
}

//______________________________________________________________________________
static void R__WriteDestructorBody(FILE *file, TIter &next)
{
   TStreamerElement *element = 0;
   next.Reset();
   while ((element = (TStreamerElement*)next())) {
      if (element->GetType() == TVirtualStreamerInfo::kObjectp || element->GetType() == TVirtualStreamerInfo::kObjectP||
          element->GetType() == TVirtualStreamerInfo::kAnyp || element->GetType() == TVirtualStreamerInfo::kAnyP
          || element->GetType() == TVirtualStreamerInfo::kAnyPnoVT)
      {
         const char *ename = element->GetName();
         const char *colon2 = strstr(ename,"::");
         if (colon2) ename = colon2+2;
         if (element->TestBit(TStreamerElement::kDoNotDelete)) {
            if(element->GetArrayLength() <= 1) {
               fprintf(file,"   %s = 0;\n",ename);
            } else {
               fprintf(file,"   memset(%s,0,%d);\n",ename,element->GetSize());
            }
         } else {
            if(element->GetArrayLength() <= 1) {
               fprintf(file,"   delete %s;   %s = 0;\n",ename,ename);
            } else {
               fprintf(file,"   for (Int_t i=0;i<%d;i++) delete %s[i];   memset(%s,0,%d);\n",element->GetArrayLength(),ename,ename,element->GetSize());
            }
         }
      }
      if (element->GetType() == TVirtualStreamerInfo::kCharStar) {
         const char *ename = element->GetName();
         if (element->TestBit(TStreamerElement::kDoNotDelete)) {
            fprintf(file,"   %s = 0;\n",ename);
         } else {
            fprintf(file,"   delete [] %s;   %s = 0;\n",ename,ename);
         }
      }
      if (TVirtualStreamerInfo::kOffsetP <= element->GetType() && element->GetType() < TVirtualStreamerInfo::kObject ) {
         const char *ename = element->GetName();
         if (element->TestBit(TStreamerElement::kDoNotDelete)) {
            fprintf(file,"   %s = 0;\n",ename);
         } else if (element->HasCounter()) {
            fprintf(file,"   delete %s;   %s = 0;\n",ename,ename);
         } else {
            fprintf(file,"   delete [] %s;   %s = 0;\n",ename,ename);
         }
      }
      if (element->GetType() == TVirtualStreamerInfo::kSTL || element->GetType() == TVirtualStreamerInfo::kSTLp) {
         const char *ename = element->GetName();
         const char *prefix = "";
         if ( element->GetType() == TVirtualStreamerInfo::kSTLp ) {
            prefix = "*";
         } else if ( element->IsBase() ) {
            ename = "this";
         }
         TClass *cle = element->GetClassPointer();
         TVirtualCollectionProxy *proxy = cle ? element->GetClassPointer()->GetCollectionProxy() : 0;
         if (!element->TestBit(TStreamerElement::kDoNotDelete) && proxy) {
            Int_t stltype = ((TStreamerSTL*)element)->GetSTLtype();

            if (proxy->HasPointers()) {
               fprintf(file,"   std::for_each( (%s %s).rbegin(), (%s %s).rend(), DeleteObjectFunctor() );\n",prefix,ename,prefix,ename);
               //fprintf(file,"      %s::iterator iter;\n");
               //fprintf(file,"      %s::iterator begin = (%s %s).begin();\n");
               //fprintf(file,"      %s::iterator end (%s %s).end();\n");
               //fprintf(file,"      for( iter = begin; iter != end; ++iter) { delete *iter; }\n");
            } else {
               if (stltype == ROOT::kSTLmap || stltype == ROOT::kSTLmultimap) {
                  TString enamebasic = TMakeProject::UpdateAssociativeToVector(element->GetTypeNameBasic());
                  std::vector<std::string> inside;
                  int nestedLoc;
                  TClassEdit::GetSplit(enamebasic, inside, nestedLoc, TClassEdit::kLong64);
                  if (inside[1][inside[1].size()-1]=='*' || inside[2][inside[2].size()-1]=='*') {
                     fprintf(file,"   std::for_each( (%s %s).rbegin(), (%s %s).rend(), DeleteObjectFunctor() );\n",prefix,ename,prefix,ename);
                  }
               }
               }
         }
         if ( prefix[0] ) {
            fprintf(file,"   delete %s;   %s = 0;\n",ename,ename);
         }
      }
   }
}

//______________________________________________________________________________
void TStreamerInfo::GenerateDeclaration(FILE *fp, FILE *sfp, const TList *subClasses, Bool_t top)
{
   // Write the Declaration of class.

   if (fClassVersion == -3) {
      return;
   }

   Bool_t needGenericTemplate = fElements==0 || fElements->GetEntries() == 0;
   Bool_t isTemplate = kFALSE;
   const char *clname = GetName();
   TString template_protoname;
   if (strchr(clname, ':')) {
      // We might have a namespace in front of the classname.
      Int_t len = strlen(clname);
      const char *name = clname;
      UInt_t nest = 0;
      UInt_t pr_pos = 0;
      for (Int_t cur = 0; cur < len; ++cur) {
         switch (clname[cur]) {
            case '<':
               ++nest;
               pr_pos = cur;
               isTemplate = kTRUE;
               break;
            case '>':
               if (nest == 0) { cur = len; continue; } // the name is not well formed, give up.
               --nest;
               break;
            case ':': {
               if (nest == 0 && clname[cur+1] == ':') {
                  // We have a scope
                  isTemplate = kFALSE;
                  name = clname + cur + 2;
               }
               break;
            }
         }
      }
      if (isTemplate) {
         template_protoname.Append(clname,pr_pos);
      }
      clname = name;
   } else {
      const char *where = strstr(clname, "<");
      isTemplate = where != 0;
      if (isTemplate) {
         template_protoname.Append(clname,where-clname);
      }
   }

   if (needGenericTemplate && isTemplate) {
      TString templateName(TMakeProject::GetHeaderName("template "+template_protoname,0));
      fprintf(fp, "#ifndef %s_h\n", templateName.Data());
      fprintf(fp, "#define %s_h\n", templateName.Data());
   }

   TString protoname;
   UInt_t numberOfNamespaces = TMakeProject::GenerateClassPrefix(fp, GetName(), top, protoname, 0, kFALSE, needGenericTemplate);

   // Generate class statement with base classes.
   TStreamerElement *element;
   TIter next(fElements);
   Int_t nbase = 0;
   while ((element = (TStreamerElement*)next())) {
      if (!element->IsBase()) continue;
      nbase++;
      const char *ename = element->GetName();
      if (nbase == 1) fprintf(fp," : public %s",ename);
      else            fprintf(fp," , public %s",ename);
   }
   fprintf(fp," {\n");

   // Generate forward declaration nested classes.
   if (subClasses && subClasses->GetEntries()) {
      Bool_t needheader = true;

      TIter subnext(subClasses);
      TStreamerInfo *subinfo;
      Int_t len = strlen(GetName());
      while ((subinfo = (TStreamerInfo*)subnext())) {
         if (strncmp(GetName(),subinfo->GetName(),len)==0 && (subinfo->GetName()[len]==':') ) {
            if (subinfo->GetName()[len+1]==':' && strstr(subinfo->GetName()+len+2,":")==0) {
               if (needheader) {
                  fprintf(fp,"\npublic:\n");
                  fprintf(fp,"// Nested classes forward declaration.\n");
                  needheader = false;
               }
               TString sub_protoname;
               UInt_t sub_numberOfClasses = 0;
               UInt_t sub_numberOfNamespaces;
               if (subinfo->GetClassVersion() == -3) {
                  sub_numberOfNamespaces = TMakeProject::GenerateClassPrefix(fp, subinfo->GetName() + len+2, kFALSE, sub_protoname, &sub_numberOfClasses, 3);
               } else {
                  sub_numberOfNamespaces = TMakeProject::GenerateClassPrefix(fp, subinfo->GetName() + len+2, kFALSE, sub_protoname, &sub_numberOfClasses, kFALSE);
                  fprintf(fp, ";\n");
               }

               for (UInt_t i = 0;i < sub_numberOfClasses;++i) {
                  fprintf(fp, "}; // end of class.\n");
               }
               if (sub_numberOfNamespaces > 0) {
                  Error("GenerateDeclaration","Nested classes %s thought to be inside a namespace inside the class %s",subinfo->GetName(),GetName());
               }
            }
         }
      }
   }

   fprintf(fp,"\npublic:\n");
   fprintf(fp,"// Nested classes declaration.\n");

   // Generate nested classes.
   if (subClasses && subClasses->GetEntries()) {
      TIter subnext(subClasses,kIterBackward);
      TStreamerInfo *subinfo;
      Int_t len = strlen(GetName());
      while ((subinfo = (TStreamerInfo*)subnext())) {
         if (strncmp(GetName(),subinfo->GetName(),len)==0 && (subinfo->GetName()[len]==':')) {
            if (subinfo->GetName()[len+1]==':' && strstr(subinfo->GetName()+len+2,":")==0) {
               subinfo->GenerateDeclaration(fp, sfp, subClasses, kFALSE);
            }
         }
      }
   }

   fprintf(fp,"\npublic:\n");
   fprintf(fp,"// Data Members.\n");

   {
      // Generate data members.
      TString name(128);
      Int_t ltype = 12;
      Int_t ldata = 10;
      Int_t lt,ld,is;
      TString line;
      line.Resize(kMaxLen);
      next.Reset();
      while ((element = (TStreamerElement*)next())) {

         if (element->IsBase()) continue;
         const char *ename = element->GetName();

         name = ename;
         for (Int_t i=0;i < element->GetArrayDim();i++) {
            name += TString::Format("[%d]",element->GetMaxIndex(i));
         }
         name += ";";
         ld = name.Length();

         TString enamebasic = element->GetTypeNameBasic();
         if (element->IsA() == TStreamerSTL::Class()) {
            // If we have a map, multimap, set or multiset,
            // and the key is a class, we need to replace the
            // container by a vector since we don't have the
            // comparator function.
            Int_t stltype = ((TStreamerSTL*)element)->GetSTLtype();
            switch (stltype) {
               case ROOT::kSTLmap:
               case ROOT::kSTLmultimap:
               case ROOT::kSTLset:
               case ROOT::kSTLmultiset:
               {
                  enamebasic = TMakeProject::UpdateAssociativeToVector(enamebasic);
               }
               default:
                  // nothing to do.
                  break;
            }
         }

         lt = enamebasic.Length();

         line = "   ";
         line += enamebasic;
         if (lt>=ltype) ltype = lt+1;

         for (is = 3+lt; is < (3+ltype); ++is) line += ' ';

         line += name;
         if (element->IsaPointer() && !strchr(line,'*')) line[2+ltype] = '*';

         if (ld>=ldata) ldata = ld+1;
         for (is = 3+ltype+ld; is < (3+ltype+ldata); ++is) line += ' ';

         line += "   //";
         line += element->GetTitle();
         fprintf(fp,"%s\n",line.Data());
      }
   }
   if (needGenericTemplate && isTemplate) {
      // Generate default functions, ClassDef and trailer.
      fprintf(fp,"\n   %s() {\n",protoname.Data());
      R__WriteConstructorBody(fp,next);
      fprintf(fp,"   }\n");
      fprintf(fp,"   %s(const %s & rhs )\n",protoname.Data(),protoname.Data());
      R__WriteMoveConstructorBody(fp,protoname,next);
      fprintf(fp,"   }\n");
      fprintf(fp,"   virtual ~%s() {\n",protoname.Data());
      R__WriteDestructorBody(fp,next);
      fprintf(fp,"   }\n\n");

   } else {
      // Generate default functions, ClassDef and trailer.
      fprintf(fp,"\n   %s();\n",protoname.Data());
      fprintf(fp,"   %s(const %s & );\n",protoname.Data(),protoname.Data());
      fprintf(fp,"   virtual ~%s();\n\n",protoname.Data());

      // Add the implementations to the source.cxx file.
      TString guard( TMakeProject::GetHeaderName( GetName(), 0, kTRUE ) );
      fprintf(sfp,"#ifndef %s_cxx\n",guard.Data());
      fprintf(sfp,"#define %s_cxx\n",guard.Data());
      fprintf(sfp,"%s::%s() {\n",GetName(),protoname.Data());
      R__WriteConstructorBody(sfp,next);
      fprintf(sfp,"}\n");

      fprintf(sfp,"%s::%s(const %s & rhs)\n",GetName(),protoname.Data(),protoname.Data());
      R__WriteMoveConstructorBody(sfp,protoname,next);
      fprintf(sfp,"}\n");

      fprintf(sfp,"%s::~%s() {\n",GetName(),protoname.Data());
      R__WriteDestructorBody(sfp,next);
      fprintf(sfp,"}\n");
      fprintf(sfp,"#endif // %s_cxx\n\n",guard.Data());
   }

   TClass *cl = gROOT->GetClass(GetName());
   if (fClassVersion > 1 || (cl && cl->IsTObject()) ) {
      // add 1 to class version in case we didn't manage reproduce the class layout to 100%.
      if (fClassVersion == 0) {
         // If the class was declared 'transient', keep it that way.
         fprintf(fp,"   ClassDef(%s,%d); // Generated by MakeProject.\n",protoname.Data(),0);
      } else {
         fprintf(fp,"   ClassDef(%s,%d); // Generated by MakeProject.\n",protoname.Data(),fClassVersion + 1);
      }
   }
   fprintf(fp,"};\n");

   for(UInt_t i=0;i<numberOfNamespaces;++i) {
      fprintf(fp,"} // namespace\n");
   }

   if (needGenericTemplate && isTemplate) {
      fprintf(fp,"#endif // generic template declaration\n");
   }
}

//______________________________________________________________________________
UInt_t TStreamerInfo::GenerateIncludes(FILE *fp, char *inclist, const TList *extrainfos)
{
   // Add to the header file, the #include need for this class

   UInt_t ninc = 0;

   const char *clname = GetName();
   if (strchr(clname,'<')) {
      // This is a template, we need to check the template parameter.
      ninc += TMakeProject::GenerateIncludeForTemplate(fp, clname, inclist, kFALSE, extrainfos);
   }

   TString name(1024);
   Int_t ltype = 10;
   Int_t ldata = 10;
   Int_t lt;
   Int_t ld;
   TIter next(fElements);
   TStreamerElement *element;
   Bool_t incRiostream = kFALSE;
   while ((element = (TStreamerElement*)next())) {
      //if (element->IsA() == TStreamerBase::Class()) continue;
      const char *ename = element->GetName();
      const char *colon2 = strstr(ename,"::");
      if (colon2) ename = colon2+2;
      name = ename;
      for (Int_t i=0;i < element->GetArrayDim();i++) {
         name += TString::Format("[%d]",element->GetMaxIndex(i));
      }
      ld = name.Length();
      lt = strlen(element->GetTypeName());
      if (ltype < lt) ltype = lt;
      if (ldata < ld) ldata = ld;

      //must include Riostream.h in case of an STL container
      if (!incRiostream && element->InheritsFrom(TStreamerSTL::Class())) {
         incRiostream = kTRUE;
         TMakeProject::AddInclude( fp, "Riostream.h", kFALSE, inclist);
      }

      //get include file name if any
      const char *include = element->GetInclude();
      if (!include[0]) continue;

      Bool_t greater = (include[0]=='<');
      include++;

      if (strncmp(include,"include/",8)==0) {
         include += 8;
      }
      if (strncmp(include,"include\\",9)==0) {
         include += 9;
      }
      if (strncmp(element->GetTypeName(),"pair<",strlen("pair<"))==0) {
         TMakeProject::AddInclude( fp, "utility", kTRUE, inclist);
      } else if (strncmp(element->GetTypeName(),"auto_ptr<",strlen("auto_ptr<"))==0) {
         TMakeProject::AddInclude( fp, "memory", kTRUE, inclist);
      } else {
         TString incName( include, strlen(include)-1 );
         incName = TMakeProject::GetHeaderName(incName,extrainfos);
         TMakeProject::AddInclude( fp, incName.Data(), greater, inclist);
      }

      if (strchr(element->GetTypeName(),'<')) {
         // This is a template, we need to check the template parameter.
         ninc += TMakeProject::GenerateIncludeForTemplate(fp, element->GetTypeName(), inclist, kFALSE, extrainfos);
      }
   }
   if (inclist[0]==0) {
      TMakeProject::AddInclude( fp, "TNamed.h", kFALSE, inclist);
   }
   return ninc;
}

//______________________________________________________________________________
Int_t TStreamerInfo::GenerateHeaderFile(const char *dirname, const TList *subClasses, const TList *extrainfos)
{
   // Generate header file for the class described by this TStreamerInfo
   // the function is called by TFile::MakeProject for each class in the file

   // if (fClassVersion == -4) return 0;
   if (TClassEdit::IsSTLCont(GetName())) return 0;
   if (strncmp(GetName(),"pair<",strlen("pair<"))==0) return 0;
   if (strncmp(GetName(),"auto_ptr<",strlen("auto_ptr<"))==0) return 0;

   TClass *cl = TClass::GetClass(GetName());
   if (cl) {
      if (cl->HasInterpreterInfo()) return 0; // skip known classes
   }
   Bool_t isTemplate = kFALSE;
   if (strchr(GetName(),':')) {
      UInt_t len = strlen(GetName());
      UInt_t nest = 0;
      UInt_t scope = 0;
      for(UInt_t i=len; i>0; --i) {
         switch(GetName()[i]) {
            case '>': ++nest; if (scope==0) { isTemplate = kTRUE; } break;
            case '<': --nest; break;
            case ':':
               if (nest==0 && GetName()[i-1]==':') {
                  // We have a scope
                  TString nsname(GetName(), i-1);
                  cl = gROOT->GetClass(nsname);
                  if (cl && (cl->Size()!=0 || (cl->Size()==0 && !cl->HasInterpreterInfo() /*empty 'base' class on file*/))) {
                     // This class is actually nested.
                     return 0;
                  } else if (cl == 0 && extrainfos != 0) {
                     TStreamerInfo *clinfo = (TStreamerInfo*)extrainfos->FindObject(nsname);
                     if (clinfo && clinfo->GetClassVersion() == -5) {
                        // This class is actually nested.
                        return 0;
                     }
                  }
                  ++scope;
               }
               break;
         }
      }
   }
   Bool_t needGenericTemplate = isTemplate && (fElements==0 || fElements->GetEntries()==0);

   if (gDebug) printf("generating code for class %s\n",GetName());

   // Open the file

   TString headername( TMakeProject::GetHeaderName( GetName(), extrainfos ) );
   TString filename;
   filename.Form("%s/%s.h",dirname,headername.Data());

   FILE *fp = fopen(filename.Data(),"w");
   if (!fp) {
      Error("MakeProject","Cannot open output file:%s\n",filename.Data());
      return 0;
   }

   filename.Form("%s/%sProjectHeaders.h",dirname,gSystem->BaseName(dirname));
   FILE *allfp = fopen(filename.Data(),"a");
   if (!allfp) {
      Error("MakeProject","Cannot open output file:%s\n",filename.Data());
      fclose(fp);
      return 0;
   }
   fprintf(allfp,"#include \"%s.h\"\n", headername.Data());
   fclose(allfp);

   char *inclist = new char[50000];
   inclist[0] = 0;

   // Generate class header.
   TDatime td;
   fprintf(fp,"//////////////////////////////////////////////////////////\n");
   fprintf(fp,"//   This class has been generated by TFile::MakeProject\n");
   fprintf(fp,"//     (%s by ROOT version %s)\n",td.AsString(),gROOT->GetVersion());
   fprintf(fp,"//      from the StreamerInfo in file %s\n",gDirectory->GetFile()->GetName());
   fprintf(fp,"//////////////////////////////////////////////////////////\n");
   fprintf(fp,"\n");
   fprintf(fp,"\n");
   fprintf(fp,"#ifndef %s_h\n",headername.Data());
   fprintf(fp,"#define %s_h\n",headername.Data());
   TMakeProject::GenerateForwardDeclaration(fp, GetName(), inclist, kFALSE, needGenericTemplate, extrainfos);
   fprintf(fp,"\n");

   UInt_t ninc = 0;
   ninc += GenerateIncludes(fp, inclist, extrainfos);
   if (subClasses) {
      TIter subnext(subClasses);
      TStreamerInfo *subinfo;
      while ((subinfo = (TStreamerInfo*)subnext())) {
         ninc = subinfo->GenerateIncludes(fp, inclist, extrainfos);
      }
   }
   fprintf(fp,"\n");

   TString sourcename; sourcename.Form( "%s/%sProjectSource.cxx", dirname, gSystem->BaseName(dirname) );
   FILE *sfp = fopen( sourcename.Data(), "a" );
   if (sfp) {
      GenerateDeclaration(fp, sfp, subClasses);
   } else {
      Error("GenerateHeaderFile","Could not open %s for appending",sourcename.Data());
   }
   TMakeProject::GeneratePostDeclaration(fp, this, inclist);

   fprintf(fp,"#endif\n");

   delete [] inclist;
   fclose(fp);
   if (sfp) fclose(sfp);
   return 1;
}

//______________________________________________________________________________
Int_t TStreamerInfo::GetDataMemberOffset(TDataMember *dm, TMemberStreamer *&streamer) const
{
   // Compute data member offset
   // return pointer to the Streamer function if one exists

   TIter nextr(fClass->GetListOfRealData());
   char dmbracket[256];
   snprintf(dmbracket,255,"%s[",dm->GetName());
   Int_t offset = kMissing;
   if (!fClass->IsLoaded()) {
      // If the 'class' is not loaded, we do not have a TClass bootstrap and thus
      // the 'RealData' might not have enough information because of the lack
      // of proper ShowMember imlementation.
      if (! (dm->Property() & kIsStatic) ) {
         // Give an offset only to non-static members.
         offset = dm->GetOffset();
      }
   }
   TRealData *rdm;
   while ((rdm = (TRealData*)nextr())) {
      char *rdmc = (char*)rdm->GetName();
      //next statement required in case a class and one of its parent class
      //have data members with the same name
      if (dm->IsaPointer() && rdmc[0] == '*') rdmc++;

      if (rdm->GetDataMember() != dm) continue;
      if (strcmp(rdmc,dm->GetName()) == 0) {
         offset   = rdm->GetThisOffset();
         streamer = rdm->GetStreamer();
         break;
      }
      if (strcmp(rdm->GetName(),dm->GetName()) == 0) {
         if (rdm->IsObject()) {
            offset = rdm->GetThisOffset();
            streamer = rdm->GetStreamer();
            break;
         }
      }
      if (strstr(rdm->GetName(),dmbracket)) {
         offset   = rdm->GetThisOffset();
         streamer = rdm->GetStreamer();
         break;
      }
   }
   return offset;
}

//______________________________________________________________________________
Int_t TStreamerInfo::GetOffset(const char *elementName) const
{
   // return the offset of the data member as indicated by this StreamerInfo

   if (elementName == 0) return 0;

   Int_t offset = 0;
   TStreamerElement *elem = (TStreamerElement*)fElements->FindObject(elementName);
   if (elem) offset = elem->GetOffset();

   return offset;
}

//______________________________________________________________________________
Int_t TStreamerInfo::GetSize() const
{
   //  return total size of all persistent elements of the class (with offsets)

   return fSize;
}

//______________________________________________________________________________
Int_t TStreamerInfo::GetSizeElements() const
{
   //  return total size of all persistent elements of the class
   //  use GetSize if you want to get the real size in memory

   TIter next(fElements);
   TStreamerElement *element;
   Int_t asize = 0;
   while ((element = (TStreamerElement*)next())) {
      asize += element->GetSize();
   }
   return asize;
}

//______________________________________________________________________________
TStreamerElement* TStreamerInfo::GetStreamerElement(const char* datamember, Int_t& offset) const
{
   // Return the StreamerElement of "datamember" inside our
   // class or any of its base classes.  The offset information
   // contained in the StreamerElement is related to its immediately
   // containing class, so we return in 'offset' the offset inside
   // our class.

   if (!fElements) {
      return 0;
   }

   // Look first at the data members and base classes
   // of our class.
   TStreamerElement* element = (TStreamerElement*) fElements->FindObject(datamember);
   if (element) {
      offset = element->GetOffset();
      return element;
   }

   // Not found, so now try the data members and base classes
   // of the base classes of our class.
   if (fClass->HasDataMemberInfo()) {
      // Our class has a dictionary loaded, use it to search the base classes.
      TStreamerElement* base_element = 0;
      TBaseClass* base = 0;
      TClass* base_cl = 0;
      Int_t base_offset = 0;
      Int_t local_offset = 0;
      TIter nextb(fClass->GetListOfBases());
      // Iterate on list of base classes.
      while ((base = (TBaseClass*) nextb())) {
         base_cl = TClass::GetClass(base->GetName());
         base_element = (TStreamerElement*) fElements->FindObject(base->GetName());
         if (!base_cl || !base_element) {
            continue;
         }
         base_offset = base_element->GetOffset();
         element = ((TStreamerInfo*)base_cl->GetStreamerInfo())->GetStreamerElement(datamember, local_offset);
         if (element) {
            offset = base_offset + local_offset;
            return element;
         }
      }
   } else {
      // Our class's dictionary is not loaded. Search through the base class streamer elements.
      TIter next(fElements);
      TStreamerElement* curelem = 0;
      while ((curelem = (TStreamerElement*) next())) {
         if (curelem->InheritsFrom(TStreamerBase::Class())) {
            TClass* baseClass = curelem->GetClassPointer();
            if (!baseClass) {
               continue;
            }
            Int_t base_offset = curelem->GetOffset();
            Int_t local_offset = 0;
            TStreamerInfo *baseInfo;
            if (baseClass->Property() & kIsAbstract) {
               baseInfo = (TStreamerInfo*)baseClass->GetStreamerInfoAbstractEmulated();
            } else {
               baseInfo = (TStreamerInfo*)baseClass->GetStreamerInfo();
            }
            if (baseInfo) element = baseInfo->GetStreamerElement(datamember, local_offset);
            if (element) {
               offset = base_offset + local_offset;
               return element;
            }
         }
      }
   }
   return 0;
}

//______________________________________________________________________________
TStreamerElement* TStreamerInfo::GetStreamerElementReal(Int_t i, Int_t j) const
{
   //
   //  This routine is obsolete and should not longer be used.
   //
   //  TStreamerInfo  holds two types of data structures
   //    -TObjArray* fElements; containing the list of all TStreamerElement
   //       objects for this class version.
   //    -ULong_t*  fElem;  containing the preprocessed information
   //       by TStreamerInfo::Compile In case consecutive data members
   //       are of the same type, the Compile function declares the consecutive
   //       elements as one single element in fElems.
   //
   //  example with the class TAttLine
   //   TClass::GetClass("TAttLine")->GetStreamerInfo()->ls(); produces;
   //      StreamerInfo for class: TAttLine, version=1
   //       short        fLineColor      offset=  4 type= 2 line color
   //       short        fLineStyle      offset=  6 type= 2 line style
   //       short        fLineWidth      offset=  8 type= 2 line width
   //        i= 0, fLineColor      type= 22, offset=  4, len=3, method=0
   //  For I/O implementations (eg. XML) , one has to know the original name
   //  of the data member. This function can be used to return a pointer
   //  to the original TStreamerElement object corresponding to the j-th
   //  element of a compressed array in fElems.
   //
   //  parameters description:
   //    - i: the serial number in array fElem
   //    - j: the element number in the array of consecutive types
   //  In the above example the class TAttLine has 3 consecutive data members
   //  of the same type "short". Compile makes one single array of 3 elements.
   //  To access the TStreamerElement for the second element
   //  of this array, one can call:
   //     TStreamerElement *el = GetStreamerElementReal(0,1);
   //     const char* membername = el->GetName();
   //  This function is typically called from TBuffer, TXmlBuffer

   ::Obsolete("TStreamerInfo::GetStreamerElementReal", "v5-34-20", "v6-00-02");

   if (i < 0 || i >= fNdata) return 0;
   if (j < 0) return 0;
   if (!fElements) return 0;
   TStreamerElement *se = (TStreamerElement*)fCompOpt[i]->fElem;
   if (!se) return 0;
   Int_t nelems = fElements->GetEntriesFast();
   for (Int_t ise=0;ise < nelems;ise++) {
      if (se != (TStreamerElement*)fElements->UncheckedAt(ise)) continue;
      if (ise+j >= nelems) return 0;
      return (TStreamerElement*)fElements->UncheckedAt(ise+j);
   }
   return 0;
}

//______________________________________________________________________________
template <typename T>
T TStreamerInfo::GetTypedValueAux(Int_t type, void *ladd, Int_t k, Int_t len)
{
   // Get the value from inside a collection.

   if (type>=kConv && type<kSTL) {
      type -= kConv;
   }
   switch (type) {
      // basic types
      case kBool:              {Bool_t *val   = (Bool_t*)ladd;   return T(*val);}
      case kChar:              {Char_t *val   = (Char_t*)ladd;   return T(*val);}
      case kShort:             {Short_t *val  = (Short_t*)ladd;  return T(*val);}
      case kInt:               {Int_t *val    = (Int_t*)ladd;    return T(*val);}
      case kLong:              {Long_t *val   = (Long_t*)ladd;   return T(*val);}
      case kLong64:            {Long64_t *val = (Long64_t*)ladd; return T(*val);}
      case kFloat:             {Float_t *val  = (Float_t*)ladd;  return T(*val);}
      case kFloat16:           {Float_t *val  = (Float_t*)ladd;  return T(*val);}
      case kDouble:            {Double_t *val = (Double_t*)ladd; return T(*val);}
      case kDouble32:          {Double_t *val = (Double_t*)ladd; return T(*val);}
      case kUChar:             {UChar_t *val  = (UChar_t*)ladd;  return T(*val);}
      case kUShort:            {UShort_t *val = (UShort_t*)ladd; return T(*val);}
      case kUInt:              {UInt_t *val   = (UInt_t*)ladd;   return T(*val);}
      case kULong:             {ULong_t *val  = (ULong_t*)ladd;  return T(*val);}
#if defined(_MSC_VER) && (_MSC_VER <= 1200)
      case kULong64:           {Long64_t *val = (Long64_t*)ladd;  return T(*val);}
#else
      case kULong64:           {ULong64_t *val= (ULong64_t*)ladd; return T(*val);}
#endif
      case kBits:              {UInt_t *val   = (UInt_t*)ladd;   return T(*val);}

         // array of basic types  array[8]
      case kOffsetL + kBool:    {Bool_t *val   = (Bool_t*)ladd;   return T(val[k]);}
      case kOffsetL + kChar:    {Char_t *val   = (Char_t*)ladd;   return T(val[k]);}
      case kOffsetL + kShort:   {Short_t *val  = (Short_t*)ladd;  return T(val[k]);}
      case kOffsetL + kInt:     {Int_t *val    = (Int_t*)ladd;    return T(val[k]);}
      case kOffsetL + kLong:    {Long_t *val   = (Long_t*)ladd;   return T(val[k]);}
      case kOffsetL + kLong64:  {Long64_t *val = (Long64_t*)ladd; return T(val[k]);}
      case kOffsetL + kFloat:   {Float_t *val  = (Float_t*)ladd;  return T(val[k]);}
      case kOffsetL + kFloat16: {Float_t *val  = (Float_t*)ladd;  return T(val[k]);}
      case kOffsetL + kDouble:  {Double_t *val = (Double_t*)ladd; return T(val[k]);}
      case kOffsetL + kDouble32:{Double_t *val = (Double_t*)ladd; return T(val[k]);}
      case kOffsetL + kUChar:   {UChar_t *val  = (UChar_t*)ladd;  return T(val[k]);}
      case kOffsetL + kUShort:  {UShort_t *val = (UShort_t*)ladd; return T(val[k]);}
      case kOffsetL + kUInt:    {UInt_t *val   = (UInt_t*)ladd;   return T(val[k]);}
      case kOffsetL + kULong:   {ULong_t *val  = (ULong_t*)ladd;  return T(val[k]);}
#if defined(_MSC_VER) && (_MSC_VER <= 1200)
      case kOffsetL + kULong64: {Long64_t *val = (Long64_t*)ladd;  return T(val[k]);}
#else
      case kOffsetL + kULong64:{ULong64_t *val= (ULong64_t*)ladd; return T(val[k]);}
#endif

#define READ_ARRAY(TYPE_t)                               \
         {                                               \
            Int_t sub_instance, index;                   \
            Int_t instance = k;                          \
            if (len) {                                   \
               index = instance / len;                   \
               sub_instance = instance % len;            \
            } else {                                     \
               index = instance;                         \
               sub_instance = 0;                         \
            }                                            \
            TYPE_t **val =(TYPE_t**)(ladd);              \
            return T((val[sub_instance])[index]); \
         }

         // pointer to an array of basic types  array[n]
      case kOffsetP + kBool_t:    READ_ARRAY(Bool_t)
      case kOffsetP + kChar_t:    READ_ARRAY(Char_t)
      case kOffsetP + kShort_t:   READ_ARRAY(Short_t)
      case kOffsetP + kInt_t:     READ_ARRAY(Int_t)
      case kOffsetP + kLong_t:    READ_ARRAY(Long_t)
      case kOffsetP + kLong64_t:  READ_ARRAY(Long64_t)
      case kOffsetP + kFloat16_t:
      case kOffsetP + kFloat_t:   READ_ARRAY(Float_t)
      case kOffsetP + kDouble32_t:
      case kOffsetP + kDouble_t:  READ_ARRAY(Double_t)
      case kOffsetP + kUChar_t:   READ_ARRAY(UChar_t)
      case kOffsetP + kUShort_t:  READ_ARRAY(UShort_t)
      case kOffsetP + kUInt_t:    READ_ARRAY(UInt_t)
      case kOffsetP + kULong_t:   READ_ARRAY(ULong_t)
#if defined(_MSC_VER) && (_MSC_VER <= 1200)
      case kOffsetP + kULong64_t: READ_ARRAY(Long64_t)
#else
      case kOffsetP + kULong64_t: READ_ARRAY(ULong64_t)
#endif

          // array counter //[n]
      case kCounter:           {Int_t *val    = (Int_t*)ladd;    return T(*val);}
   }
   return 0;
}

//______________________________________________________________________________
template Double_t TStreamerInfo::GetTypedValue(char *pointer, Int_t i, Int_t j, Int_t len) const;
template Long64_t TStreamerInfo::GetTypedValue(char *pointer, Int_t i, Int_t j, Int_t len) const;
template LongDouble_t TStreamerInfo::GetTypedValue(char *pointer, Int_t i, Int_t j, Int_t len) const;

template <typename T>
T TStreamerInfo::GetTypedValue(char *pointer, Int_t i, Int_t j, Int_t len) const
{
   //  return value of element i in object at pointer.
   //  The function may be called in two ways:
   //    -method1  len < 0
   //           i is assumed to be the TStreamerElement number i in StreamerInfo
   //    -method2  len >= 0
   //           i is the type
   //           address of variable is directly pointer.

   char *ladd;
   Int_t atype;
   if (len >= 0) {
      ladd  = pointer;
      atype = i;
   } else {
      if (i < 0) return 0;
      ladd  = pointer + fCompFull[i]->fOffset;
      atype = fCompFull[i]->fNewType;
      len = fCompFull[i]->fElem->GetArrayLength();
      if (atype == kSTL) {
         TClass *newClass = fCompFull[i]->fElem->GetNewClass();
         if (newClass == 0) {
            newClass = fCompFull[i]->fElem->GetClassPointer();
         }
         TClass *innerClass = newClass->GetCollectionProxy()->GetValueClass();
         if (innerClass) {
            return 0; // We don't know which member of the class we would want.
         } else {
            TVirtualCollectionProxy *proxy = newClass->GetCollectionProxy();
            // EDataType is a subset of TStreamerInfo::EReadWrite
            atype = (TStreamerInfo::EReadWrite)proxy->GetType();
            TVirtualCollectionProxy::TPushPop pop(proxy,ladd);
            Int_t nc = proxy->Size();
            if (j >= nc) return 0;
            char *element_ptr = (char*)proxy->At(j);
            return GetTypedValueAux<T>(atype,element_ptr,0,1);
         }
      }
   }
   return GetTypedValueAux<T>(atype,ladd,j,len);
}

//______________________________________________________________________________
template Double_t TStreamerInfo::GetTypedValueClones<Double_t>(TClonesArray *clones, Int_t i, Int_t j, int k, Int_t eoffset) const;
template Long64_t TStreamerInfo::GetTypedValueClones(TClonesArray *clones, Int_t i, Int_t j, int k, Int_t eoffset) const;
template LongDouble_t TStreamerInfo::GetTypedValueClones(TClonesArray *clones, Int_t i, Int_t j, int k, Int_t eoffset) const;

template <typename T>
T TStreamerInfo::GetTypedValueClones(TClonesArray *clones, Int_t i, Int_t j, int k, Int_t eoffset) const
{
   //  return value of element i in object number j in a TClonesArray and eventually
   // element k in a sub-array.

   Int_t nc = clones->GetEntriesFast();
   if (j >= nc) return 0;

   char *pointer = (char*)clones->UncheckedAt(j);
   char *ladd    = pointer + eoffset + fCompFull[i]->fOffset;
   return GetTypedValueAux<T>(fCompFull[i]->fType,ladd,k,((TStreamerElement*)fCompFull[i]->fElem)->GetArrayLength());
}

//______________________________________________________________________________
template Double_t TStreamerInfo::GetTypedValueSTL(TVirtualCollectionProxy *cont, Int_t i, Int_t j, int k, Int_t eoffset) const;
template Long64_t TStreamerInfo::GetTypedValueSTL(TVirtualCollectionProxy *cont, Int_t i, Int_t j, int k, Int_t eoffset) const;
template LongDouble_t TStreamerInfo::GetTypedValueSTL(TVirtualCollectionProxy *cont, Int_t i, Int_t j, int k, Int_t eoffset) const;

template <typename T>
T TStreamerInfo::GetTypedValueSTL(TVirtualCollectionProxy *cont, Int_t i, Int_t j, int k, Int_t eoffset) const
{
   //  return value of element i in object number j in a TClonesArray and eventually
   // element k in a sub-array.

   Int_t nc = cont->Size();
   if (j >= nc) return 0;

   char *pointer = (char*)cont->At(j);
   char *ladd    = pointer + eoffset + fCompFull[i]->fOffset;
   return GetTypedValueAux<T>(fCompFull[i]->fType,ladd,k,((TStreamerElement*)fCompFull[i]->fElem)->GetArrayLength());
}

//______________________________________________________________________________
template Double_t TStreamerInfo::GetTypedValueSTLP(TVirtualCollectionProxy *cont, Int_t i, Int_t j, int k, Int_t eoffset) const;
template Long64_t TStreamerInfo::GetTypedValueSTLP(TVirtualCollectionProxy *cont, Int_t i, Int_t j, int k, Int_t eoffset) const;
template LongDouble_t TStreamerInfo::GetTypedValueSTLP(TVirtualCollectionProxy *cont, Int_t i, Int_t j, int k, Int_t eoffset) const;

template <typename T>
T TStreamerInfo::GetTypedValueSTLP(TVirtualCollectionProxy *cont, Int_t i, Int_t j, int k, Int_t eoffset) const
{
   //  return value of element i in object number j in a TClonesArray and eventually
   // element k in a sub-array.
   Int_t nc = cont->Size();

   if (j >= nc) return 0;

   char **ptr = (char**)cont->At(j);
   char *pointer = *ptr;

   char *ladd    = pointer + eoffset + fCompFull[i]->fOffset;
   return GetTypedValueAux<T>(fCompFull[i]->fType,ladd,k,((TStreamerElement*)fCompFull[i]->fElem)->GetArrayLength());
}

//______________________________________________________________________________
void TStreamerInfo::InsertArtificialElements(const TObjArray *rules)
{
   // Insert new members as expressed in the array of TSchemaRule(s).

   if (!rules) return;

   TIter next(fElements);
   UInt_t count = 0;

   for(Int_t art = 0; art < rules->GetEntries(); ++art) {
      ROOT::TSchemaRule *rule = (ROOT::TSchemaRule*)rules->At(art);
      if( rule->IsRenameRule() || rule->IsAliasRule() )
         continue;
      next.Reset();
      TStreamerElement *element;
      while ((element = (TStreamerElement*) next())) {
         if ( rule->HasTarget( element->GetName() ) ) {

            // Check whether this is an 'attribute' rule.
            if ( rule->GetAttributes()[0] != 0 ) {
               TString attr( rule->GetAttributes() );
               attr.ToLower();
               if (attr.Contains("owner")) {
                  if (attr.Contains("notowner")) {
                     element->SetBit(TStreamerElement::kDoNotDelete);
                  } else {
                     element->ResetBit(TStreamerElement::kDoNotDelete);
                  }
               }

            }
            break;
         }
      }

      // NOTE: Before adding the rule we should check that the source do
      // existing in this StreamerInfo.
      const TObjArray *sources = rule->GetSource();
      TIter input(sources);
      TObject *src;
      while((src = input())) {
         if ( !GetElements()->FindObject(src->GetName()) ) {
            // Missing source.
#if 0 // Don't warn about not activating the rule.  If don't warn the user can
      // have more flexibility in specifiying when the rule applies and relying
      // on both the version number *and* the presence of the source members.
      // Activating this warning would for example mean that we need to carefully
      // tweak $ROOTSYS/etc/class.rules.
            TString ruleStr;
            rule->AsString(ruleStr);
            Warning("InsertArtificialElements","For class %s in StreamerInfo %d is missing the source data member %s when trying to apply the rule:\n   %s",
                   GetName(),GetClassVersion(),src->GetName(),ruleStr.Data());
            rule = 0;
#endif
            break;
         }
      }

      if (!rule) continue;

      TStreamerArtificial *newel;
      typedef std::vector<TStreamerArtificial*> vec_t;
      vec_t toAdd;

      if (rule->GetTarget()==0) {
         TString newName;
         newName.Form("%s_rule%d",fClass->GetName(),count);
         newel = new TStreamerArtificial(newName,"",
                                         fClass->GetDataMemberOffset(newName),
                                         TStreamerInfo::kArtificial,
                                         "void");
         newel->SetBit(TStreamerElement::kWholeObject);
         newel->SetReadFunc( rule->GetReadFunctionPointer() );
         newel->SetReadRawFunc( rule->GetReadRawFunctionPointer() );
         toAdd.push_back(newel);
      } else {
         toAdd.reserve(rule->GetTarget()->GetEntries());
         TObjString * objstr = (TObjString*)(rule->GetTarget()->At(0));
         if (objstr) {
            TString newName = objstr->String();
            TString realDataName;
            if ( TDataMember* dm = fClass->GetDataMember( newName ) ) {
               TRealData::GetName(realDataName,dm);
               newel = new TStreamerArtificial(realDataName,"",
                                               fClass->GetDataMemberOffset(newName),
                                               TStreamerInfo::kArtificial,
                                               fClass->GetDataMember( newName )->GetTypeName());
               newel->SetReadFunc( rule->GetReadFunctionPointer() );
               newel->SetReadRawFunc( rule->GetReadRawFunctionPointer() );
               toAdd.push_back(newel);
            } else {
               // This would be a completely new member (so it would need to be cached)
               // TOBEDONE
            }
            for(Int_t other = 1; other < rule->GetTarget()->GetEntries(); ++other) {
               objstr = (TObjString*)(rule->GetTarget()->At(other));
               if (objstr) {
                  newName = objstr->String();
                  if ( TDataMember* dm = fClass->GetDataMember( newName ) ) {
                     TRealData::GetName(realDataName,dm);
                     newel = new TStreamerArtificial(realDataName,"",
                                                     fClass->GetDataMemberOffset(newName),
                                                     TStreamerInfo::kArtificial,
                                                     fClass->GetDataMember( newName )->GetTypeName());
                     toAdd.push_back(newel);
                  }
               }
            }
         } // For each target of the rule
      }
      // Now find we with need to add them
      TIter s_iter(rule->GetSource());
      Int_t loc = -1;
      while( TObjString *s = (TObjString*)s_iter() ) {
         for(Int_t i = fElements->GetLast(); i >= 0 && (i+1) >= loc; --i) {
            if (s->String() == fElements->UncheckedAt(i)->GetName()) {
               if (loc == -1 || (i+1)>loc) {
                  loc = i+1;
               }
            }
         }
      }
      if (loc == -1) {
         // Verify if the last one is not 'skipped'.
         for(Int_t i = fElements->GetLast(); i >= 0 && (i+1) >= loc; --i) {
            if ( ((TStreamerElement*)fElements->UncheckedAt(i))->GetNewType() != -2 ) {
               break;
            }
            loc = i;
         }
      }
      if (loc == -1) {
         for(vec_t::iterator iter = toAdd.begin(); iter != toAdd.end(); ++iter) {
            fElements->Add(*iter);
         }
      } else {
         R__TObjArray_InsertAt(fElements, toAdd, loc);
      }
   } // None of the target of the rule are on file.
}

//______________________________________________________________________________
void TStreamerInfo::ls(Option_t *option) const
{
   //  List the TStreamerElement list and also the precomputed tables
   //  if option contains the string "incOrig", also prints the original
   //  (non-optimized elements in the list of compiled elements.

   if (fClass && (fName != fClass->GetName())) {
      if (fClass->IsVersioned()) {
         Printf("\nStreamerInfo for conversion to %s from: %s, version=%d, checksum=0x%x",fClass->GetName(),GetName(),fClassVersion,GetCheckSum());
      } else {
         Printf("\nStreamerInfo for conversion to %s from: %s, checksum=0x%x",fClass->GetName(),GetName(),GetCheckSum());
      }
   } else {
      if (!fClass || fClass->IsVersioned()) {
         Printf("\nStreamerInfo for class: %s, version=%d, checksum=0x%x",GetName(),fClassVersion,GetCheckSum());
      } else {
         Printf("\nStreamerInfo for class: %s, checksum=0x%x",GetName(),GetCheckSum());
      }
   }

   if (fElements) {
      TIter    next(fElements);
      TObject *obj;
      while ((obj = next()))
         obj->ls(option);
   }
   if (strstr(option,"full") != 0) {
      for (Int_t i=0; i < fNfulldata; ++i) {
         TStreamerElement *element = (TStreamerElement*)fCompFull[i]->fElem;
         TString sequenceType;
         element->GetSequenceType(sequenceType);
         // by definition of the loop (i+1) <= fNdata
         if (sequenceType.Length()) {
            sequenceType.Prepend(" [");
            sequenceType += "]";
         }
         Printf("   i=%2d, %-15s type=%3d, offset=%3d, len=%d, method=%ld%s",
                i,element->GetName(),fCompFull[i]->fType,fCompFull[i]->fOffset,fCompFull[i]->fLength,fCompFull[i]->fMethod,
                sequenceType.Data());
      }

   } else {
      Bool_t wantOrig = strstr(option,"incOrig") != 0;
      Bool_t optimized = kFALSE;
      for (Int_t i=0,j=0;i < fNdata;++i,++j) {
         TStreamerElement *element = (TStreamerElement*)fCompOpt[i]->fElem;
         TString sequenceType;
         element->GetSequenceType(sequenceType);
         // by definition of the loop (i+1) <= fNdata
         optimized = TStreamerInfo::kOffsetL < fCompOpt[i]->fType && fCompOpt[i]->fType < TStreamerInfo::kOffsetP && fCompOpt[i]->fLength > fCompOpt[i]->fElem->GetArrayLength();
         if (optimized) {
            // This was optimized.
            if (sequenceType.Length() != 0) {
               sequenceType += ',';
            }
            sequenceType += "optimized";
         }
         if (sequenceType.Length()) {
            sequenceType.Prepend(" [");
            sequenceType += "]";
         }
         Printf("   i=%2d, %-15s type=%3d, offset=%3d, len=%d, method=%ld%s",
                i,element->GetName(),fCompOpt[i]->fType,fCompOpt[i]->fOffset,fCompOpt[i]->fLength,fCompOpt[i]->fMethod,
                sequenceType.Data());
         if (optimized && wantOrig) {
            Bool_t done;
            do {
               element = (TStreamerElement*)fCompFull[j]->fElem;
               element->GetSequenceType(sequenceType);
               if (sequenceType.Length()) {
                  sequenceType.Prepend(" [");
                  sequenceType += "]";
               }
               Printf("      j=%2d, %-15s type=%3d, offset=%3d, len=%d, method=%ld%s",
                      j,element->GetName(),fCompFull[j]->fType,fCompFull[j]->fOffset,fCompFull[j]->fLength,fCompFull[j]->fMethod,
                      sequenceType.Data());
               ++j;
               done = j >= fNfulldata || ( (i+1 < fNdata) && fCompOpt[i+1]->fElem == fCompFull[j+1]->fElem );
            } while (!done);

         }
      }
   }
}

//______________________________________________________________________________
void* TStreamerInfo::New(void *obj)
{
   // An emulated object is created at address obj, if obj is null we
   // allocate memory for the object.

   //???FIX ME: What about varying length array elements?

   char* p = (char*) obj;

   TIter next(fElements);

   if (!p) {
      // Allocate and initialize the memory block.
      p = new char[fSize];
      memset(p, 0, fSize);
   }

   next.Reset();
   TStreamerElement* element = (TStreamerElement*) next();

   for (; element; element = (TStreamerElement*) next()) {

      // Skip elements which have not been allocated memory.
      if (element->GetOffset() == kMissing) {
         continue;
      }

      // Skip elements for which we do not have any class
      // information.  FIXME: Document how this could happen.
      TClass* cle = element->GetClassPointer();
      if (!cle) {
         continue;
      }

      char* eaddr = p + element->GetOffset();
      Int_t etype = element->GetType();

      //cle->GetStreamerInfo(); //necessary in case "->" is not specified

      switch (etype) {

         case kAnyP:
         case kObjectP:
         case kSTLp:
         {
            // Initialize array of pointers with null pointers.
            char** r = (char**) eaddr;
            Int_t len = element->GetArrayLength();
            for (Int_t i = 0; i < len; ++i) {
               r[i] = 0;
            }
         }
         break;

         case kObjectp:
         case kAnyp:
         {
            // If the option "->" is given in the data member comment field
            // it is assumed that the object exists before reading data in,
            // so we create an object.
            if (cle != TClonesArray::Class()) {
               void** r = (void**) eaddr;
               *r = cle->New();
            } else {
               // In the case of a TClonesArray, the class name of
               // the contained objects must be specified in the
               // data member comment in this format:
               //    TClonesArray* myVar; //->(className)
               const char* title = element->GetTitle();
               const char* bracket1 = strrchr(title, '(');
               const char* bracket2 = strrchr(title, ')');
               if (bracket1 && bracket2 && (bracket2 != (bracket1 + 1))) {
                  Int_t len = bracket2 - (bracket1 + 1);
                  char* clonesClass = new char[len+1];
                  clonesClass[0] = '\0';
                  strncat(clonesClass, bracket1 + 1, len);
                  void** r = (void**) eaddr;
                  *r = (void*) new TClonesArray(clonesClass);
                  delete[] clonesClass;
               } else {
                  //Warning("New", "No class name found for TClonesArray initializer in data member comment (expected \"//->(className)\"");
                  void** r = (void**) eaddr;
                  *r = (void*) new TClonesArray();
               }
            }
         }
         break;

         case kBase:
         {
            if (cle->Property() & kIsAbstract) {
               TVirtualStreamerInfo *einfo = cle->GetStreamerInfoAbstractEmulated();
               if (einfo) einfo->New(eaddr);
            } else {
               cle->New(eaddr);
            }
            break;
         }
         case kObject:
         case kAny:
         case kTObject:
         case kTString:
         case kTNamed:
         {
            cle->New(eaddr);
         }
         break;

         case kSTL:
         {
            if (strcmp(element->GetName(),"This")==0 &&
                !cle->GetCollectionProxy()) {
               // missing information, avoid infinite loop
               // by doing nothing ....
            } else {
               cle->New(eaddr);
            }
         }
         break;

         case kObject + kOffsetL:
         case kAny + kOffsetL:
         case kTObject + kOffsetL:
         case kTString + kOffsetL:
         case kTNamed + kOffsetL:
         case kSTL + kOffsetL:
         {
            Int_t size = cle->Size();
            char* r = eaddr;
            Int_t len = element->GetArrayLength();
            for (Int_t i = 0; i < len; ++i, r += size) {
               cle->New(r);
            }
         }
         break;

      } // switch etype
   } // for TIter next(fElements)

   for(int nbase = 0; nbase < fNVirtualInfoLoc; ++nbase) {
      *(TStreamerInfo**)(p + fVirtualInfoLoc[nbase]) = this;
   }
   ++fLiveCount;
   return p;
}

//______________________________________________________________________________
void* TStreamerInfo::NewArray(Long_t nElements, void *ary)
{
   // An array of emulated objects is created at address ary, if ary is null,
   // we allocate memory for the array.

   if (fClass == 0) {
      Error("NewArray", "TClass pointer is null!");
      return 0;
   }

   Int_t size = fClass->Size();

   char* p = (char*) ary;

   if (!p) {
      Long_t len = nElements * size + sizeof(Long_t)*2;
      p = new char[len];
      memset(p, 0, len);
   }

   // Store the array cookie
   Long_t* r = (Long_t*) p;
   r[0] = size;
   r[1] = nElements;
   char* dataBegin = (char*) &r[2];

   // Do a placement new for each element.
   p = dataBegin;
   for (Long_t cnt = 0; cnt < nElements; ++cnt) {
      New(p);
      p += size;
   } // for nElements

   return dataBegin;
}


#define DeleteBasicPointer(addr,element,name)                           \
   {                                                                    \
      name **f = (name**)(addr);                                        \
      int n = element->GetArrayLength() ? element->GetArrayLength() : 1;\
      for(int j=0;j<n;j++) {                                            \
         delete [] f[j];                                                \
         f[j] = 0;                                                      \
      }                                                                 \
   }

//______________________________________________________________________________
void TStreamerInfo::DestructorImpl(void* obj, Bool_t dtorOnly)
{
   // Internal part of the destructor.
   // Destruct each of the datamembers in the same order
   // as the implicit destructor would.

   R__ASSERT(obj != 0);

   char *p = (char*)obj;

   Int_t nelements = fElements->GetEntriesFast();
   //for (; ele; ele = (TStreamerElement*) next())
   for (Int_t elenum = nelements - 1; elenum >= 0; --elenum) {
      TStreamerElement* ele = (TStreamerElement*) fElements->UncheckedAt(elenum);
      if (ele->GetOffset() == kMissing) continue;
      char* eaddr = p + ele->GetOffset();


      Int_t etype = ele->GetType();

      switch(etype) {
         case TStreamerInfo::kOffsetP + TStreamerInfo::kBool:   DeleteBasicPointer(eaddr,ele,Bool_t);  continue;
         case TStreamerInfo::kOffsetP + TStreamerInfo::kChar:   DeleteBasicPointer(eaddr,ele,Char_t);  continue;
         case TStreamerInfo::kOffsetP + TStreamerInfo::kShort:  DeleteBasicPointer(eaddr,ele,Short_t);  continue;
         case TStreamerInfo::kOffsetP + TStreamerInfo::kInt:    DeleteBasicPointer(eaddr,ele,Int_t);  continue;
         case TStreamerInfo::kOffsetP + TStreamerInfo::kLong:   DeleteBasicPointer(eaddr,ele,Long_t);  continue;
         case TStreamerInfo::kOffsetP + TStreamerInfo::kLong64: DeleteBasicPointer(eaddr,ele,Long64_t);  continue;
         case TStreamerInfo::kOffsetP + TStreamerInfo::kFloat16:
         case TStreamerInfo::kOffsetP + TStreamerInfo::kFloat:  DeleteBasicPointer(eaddr,ele,Float_t);  continue;
         case TStreamerInfo::kOffsetP + TStreamerInfo::kDouble32:
         case TStreamerInfo::kOffsetP + TStreamerInfo::kDouble: DeleteBasicPointer(eaddr,ele,Double_t);  continue;
         case TStreamerInfo::kOffsetP + TStreamerInfo::kUChar:  DeleteBasicPointer(eaddr,ele,UChar_t);  continue;
         case TStreamerInfo::kOffsetP + TStreamerInfo::kUShort: DeleteBasicPointer(eaddr,ele,UShort_t);  continue;
         case TStreamerInfo::kOffsetP + TStreamerInfo::kUInt:   DeleteBasicPointer(eaddr,ele,UInt_t);  continue;
         case TStreamerInfo::kOffsetP + TStreamerInfo::kULong:  DeleteBasicPointer(eaddr,ele,ULong_t);  continue;
         case TStreamerInfo::kOffsetP + TStreamerInfo::kULong64:DeleteBasicPointer(eaddr,ele,ULong64_t);  continue;
      }



      TClass* cle = ele->GetClassPointer();
      if (!cle) continue;


      if (etype == kObjectp || etype == kAnyp) {
         // Destroy an array of pre-allocated objects.
         Int_t len = ele->GetArrayLength();
         if (!len) {
            len = 1;
         }
         void** r = (void**) eaddr;
         for (Int_t j = len - 1; j >= 0; --j) {
            if (r[j]) {
               cle->Destructor(r[j]);
               r[j] = 0;
            }
         }
      }

      if ((etype == kObjectP || etype == kAnyP || etype == kSTLp) && !ele->TestBit(TStreamerElement::kDoNotDelete)) {
         // Destroy an array of pointers to not-pre-allocated objects.
         Int_t len = ele->GetArrayLength();
         if (!len) {
            len = 1;
         }
         void** r = (void**) eaddr;
         for (Int_t j = len - 1; j >= 0; --j) {
            if (r[j]) {
               cle->Destructor(r[j]);
               r[j] = 0;
            }
         }
      }

      if (etype == kBase) {
         if (cle->Property() & kIsAbstract) {
            TVirtualStreamerInfo *einfo = cle->GetStreamerInfoAbstractEmulated();
            if (einfo) einfo->Destructor(eaddr, kTRUE);
         } else {
            cle->Destructor(eaddr, kTRUE);
         }
     }

      if (etype == kObject || etype == kAny ||
          etype == kTObject || etype == kTString || etype == kTNamed) {
         // A data member is destroyed, but not deleted.
         cle->Destructor(eaddr, kTRUE);
     }

      if (etype == kSTL) {
         // A data member is destroyed, but not deleted.
         TVirtualCollectionProxy *pr = cle->GetCollectionProxy();
         if (!pr) {
            if (strcmp(ele->GetName(),"This")==0) {
               // missing information, avoid infinite loop
               // by doing nothing ....
            } else {
               cle->Destructor(eaddr, kTRUE);
            }
         } else {
            if (ele->TestBit(TStreamerElement::kDoNotDelete)) {
               TVirtualCollectionProxy::TPushPop env(cle->GetCollectionProxy(), eaddr); // used for both this 'clear' and the 'clear' inside destructor.
               cle->GetCollectionProxy()->Clear(); // empty the collection without deleting the pointer
               pr->Destructor(eaddr, kTRUE);
            } else {
               pr->Destructor(eaddr, kTRUE);
            }
         }
      }

      if (etype == kObject  + kOffsetL || etype == kAny     + kOffsetL ||
          etype == kTObject + kOffsetL || etype == kTString + kOffsetL ||
          etype == kTNamed  + kOffsetL || etype == kSTL     + kOffsetL) {
         // For a data member which is an array of objects, we
         // destroy the objects, but do not delete them.
         Int_t len = ele->GetArrayLength();
         Int_t size = cle->Size();
         char* r = eaddr + (size * (len - 1));
         for (Int_t j = len - 1; j >= 0; --j, r -= size) {
            cle->Destructor(r, kTRUE);
         }
      }
   } // iter over elements

   if (!dtorOnly) {
      delete[] p;
   }
   --fLiveCount;
}

//______________________________________________________________________________
void TStreamerInfo::Destructor(void* obj, Bool_t dtorOnly)
{
   // Emulated destructor for this class.
   // An emulated object is destroyed at address p.
   // Destruct each of the datamembers in the same order
   // as the implicit destructor would.

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

   char* p = (char*) obj;

   if (!dtorOnly && fNVirtualInfoLoc) {
      // !dtorOnly is used to filter out the case where this is called for
      // a base class or embeded object of the outer most class.
      TStreamerInfo *allocator = *(TStreamerInfo**)(p + fVirtualInfoLoc[0]);
      if (allocator != this) {

         Int_t baseoffset = allocator->GetClass()->GetBaseClassOffset(GetClass());

         p -= baseoffset;
         allocator->DestructorImpl(p, kFALSE);
         return;
      }
   }
   DestructorImpl(p, dtorOnly);
}

//______________________________________________________________________________
void TStreamerInfo::DeleteArray(void* ary, Bool_t dtorOnly)
{
   // Destroy an array of emulated objects, with optional delete.

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

   //???FIX ME: What about varying length arrays?

   Long_t* r = (Long_t*) ary;
   Long_t arrayLen = r[-1];
   Long_t size = r[-2];
   char* memBegin = (char*) &r[-2];

   char* p = ((char*) ary) + ((arrayLen - 1) * size);
   for (Long_t cnt = 0; cnt < arrayLen; ++cnt, p -= size) {
      // Destroy each element, but do not delete it.
      Destructor(p, kTRUE);
   } // for arrayItemSize

   if (!dtorOnly) {
      delete[] memBegin;
   }
}

//______________________________________________________________________________
void TStreamerInfo::PrintValue(const char *name, char *pointer, Int_t i, Int_t len, Int_t lenmax) const
{
   //  print value of element i in object at pointer
   //  The function may be called in two ways:
   //    -method1  len < 0
   //           i is assumed to be the TStreamerElement number i in StreamerInfo
   //    -method2  len >= 0
   //           i is the type
   //           address of variable is directly pointer.
   //           len is the number of elements to be printed starting at pointer.

   char *ladd;
   Int_t atype,aleng;
   printf(" %-15s = ",name);

   TStreamerElement * aElement  = 0;
   Int_t *count  = 0;
   if (len >= 0) {
      ladd  = pointer;
      atype = i;
      aleng = len;
   } else        {
      if (i < 0) {
         if (pointer==0) {
            printf("NULL\n");
         } else {
            const static TClassRef stringClass("string");
            if (fClass == stringClass) {
               std::string *st = (std::string*)(pointer);
               printf("%s\n",st->c_str());
            } else if (fClass == TString::Class()) {
               TString *st = (TString*)(pointer);
               printf("%s\n",st->Data());
            } else {
               printf("(%s*)0x%lx\n",GetName(),(ULong_t)pointer);
            }
         }
         return;
      }
      ladd  = pointer + fCompFull[i]->fOffset;
      atype = fCompFull[i]->fNewType;
      aleng = fCompFull[i]->fLength;
      aElement  = (TStreamerElement*)fCompFull[i]->fElem;
      count = (Int_t*)(pointer+fCompFull[i]->fMethod);
   }
   if (aleng > lenmax) aleng = lenmax;

   PrintValueAux(ladd,atype,aElement,aleng,count);
   printf("\n");
}

//______________________________________________________________________________
void TStreamerInfo::PrintValueClones(const char *name, TClonesArray *clones, Int_t i, Int_t eoffset, Int_t lenmax) const
{
   //  print value of element i in a TClonesArray

   if (!clones) {printf(" %-15s = \n",name); return;}
   printf(" %-15s = ",name);
   Int_t nc = clones->GetEntriesFast();
   if (nc > lenmax) nc = lenmax;

   Int_t offset = eoffset + fCompFull[i]->fOffset;
   TStreamerElement *aElement  = (TStreamerElement*)fCompFull[i]->fElem;
   int aleng = fCompFull[i]->fLength;
   if (aleng > lenmax) aleng = lenmax;

   for (Int_t k=0;k < nc;k++) {
      char *pointer = (char*)clones->UncheckedAt(k);
      char *ladd = pointer+offset;
      Int_t *count = (Int_t*)(pointer+fCompFull[i]->fMethod);
      PrintValueAux(ladd,fCompFull[i]->fNewType,aElement, aleng, count);
      if (k < nc-1) printf(", ");
   }
   printf("\n");
}

//______________________________________________________________________________
void TStreamerInfo::PrintValueSTL(const char *name, TVirtualCollectionProxy *cont, Int_t i, Int_t eoffset, Int_t lenmax) const
{
   //  print value of element i in a TClonesArray

   if (!cont) {printf(" %-15s = \n",name); return;}
   printf(" %-15s = ",name);
   Int_t nc = cont->Size();
   if (nc > lenmax) nc = lenmax;

   Int_t offset = eoffset + fCompFull[i]->fOffset;
   TStreamerElement *aElement  = (TStreamerElement*)fCompFull[i]->fElem;
   int aleng = fCompFull[i]->fLength;
   if (aleng > lenmax) aleng = lenmax;

   for (Int_t k=0;k < nc;k++) {
      char *pointer = (char*)cont->At(k);
      char *ladd = pointer+offset;
      Int_t *count = (Int_t*)(pointer+fCompFull[i]->fMethod);
      PrintValueAux(ladd,fCompFull[i]->fNewType,aElement, aleng, count);
      if (k < nc-1) printf(", ");
   }
   printf("\n");
}

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

   UInt_t R__s, R__c;
   if (R__b.IsReading()) {
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c);
      fOldVersion = R__v;
      if (R__v > 1) {
         //R__b.ReadClassBuffer(TStreamerInfo::Class(), this, R__v, R__s, R__c);
         R__b.ClassBegin(TStreamerInfo::Class(), R__v);
         R__b.ClassMember("TNamed");
         TNamed::Streamer(R__b);
         fName = TClassEdit::GetLong64_Name( fName.Data() ).c_str();
         R__b.ClassMember("fCheckSum","UInt_t");
         R__b >> fCheckSum;
         R__b.ClassMember("fClassVersion","Int_t");
         R__b >> fClassVersion;
         fOnFileClassVersion = fClassVersion;
         R__b.ClassMember("fElements","TObjArray*");
         R__b >> fElements;
         R__b.ClassEnd(TStreamerInfo::Class());
         R__b.SetBufferOffset(R__s+R__c+sizeof(UInt_t));
         ResetBit(kIsCompiled);
         ResetBit(kBuildOldUsed);
         ResetBit(kBuildRunning);
         return;
      }
      //====process old versions before automatic schema evolution
      TNamed::Streamer(R__b);
      fName = TClassEdit::GetLong64_Name( fName.Data() ).c_str();
      R__b >> fCheckSum;
      R__b >> fClassVersion;
      fOnFileClassVersion = fClassVersion;
      R__b >> fElements;
      R__b.CheckByteCount(R__s, R__c, TStreamerInfo::IsA());
   } else {
      R__c = R__b.WriteVersion(TStreamerInfo::IsA(), kTRUE);
      R__b.ClassBegin(TStreamerInfo::Class());
      R__b.ClassMember("TNamed");
      TNamed::Streamer(R__b);
      R__b.ClassMember("fCheckSum","UInt_t");
      R__b << fCheckSum;
      R__b.ClassMember("fClassVersion","Int_t");
      R__b << ((fClassVersion > 0) ? fClassVersion : -fClassVersion);

      //------------------------------------------------------------------------
      // Stream only non-artificial streamer elements
      //------------------------------------------------------------------------
      R__b.ClassMember("fElements","TObjArray*");
#if NOTYET
      if (has_no_artificial_member) {
         R__b << fElements;
      } else
#endif
      {
         R__LOCKGUARD(gInterpreterMutex);
         Int_t nobjects = fElements->GetEntriesFast();
         TObjArray store( *fElements );
         TStreamerElement *el;
         for (Int_t i = 0; i < nobjects; i++) {
            el = (TStreamerElement*)fElements->UncheckedAt(i);
            if( el != 0 && (el->IsA() == TStreamerArtificial::Class() || el->TestBit(TStreamerElement::kRepeat))) {
               fElements->RemoveAt( i );
            } else if( el !=0 && (el->TestBit(TStreamerElement::kCache) && !el->TestBit(TStreamerElement::kWrite)) ) {
               fElements->RemoveAt( i );
            }
         }
         fElements->Compress();
         R__b << fElements;
         R__ASSERT(!fElements->IsOwner());
         *fElements = store;
      }
      R__b.ClassEnd(TStreamerInfo::Class());
      R__b.SetByteCount(R__c, kTRUE);
   }
}

//______________________________________________________________________________
void TStreamerInfo::TagFile(TFile *file)
{
   // Mark the classindex of the current file as using this TStreamerInfo
   // This function is deprecated and its functionality is now done by
   // the overloads of TBuffer::TagStreamerInfo.

   if (file) {
      // If the value of the atomic is kFALSE (equal to expected), change its value
      // to kTRUE and return true. Leave it as it is otherwise and return false.
      static std::atomic<Bool_t> onlyonce(kFALSE);
      Bool_t expected = kFALSE;
      if (onlyonce.compare_exchange_strong(expected,kTRUE)) {
         Warning("TagFile","This function is deprecated, use TBuffer::TagStreamerInfo instead");
      }
      TArrayC *cindex = file->GetClassIndex();
      Int_t nindex = cindex->GetSize();
      if (fNumber < 0 || fNumber >= nindex) {
         Error("TagFile","StreamerInfo: %s number: %d out of range[0,%d] in file: %s",
               GetName(),fNumber,nindex,file->GetName());
         return;
      }
      if (cindex->fArray[fNumber] == 0) {
         cindex->fArray[0]       = 1;
         cindex->fArray[fNumber] = 1;
      }
   }
}

//______________________________________________________________________________
#ifdef DOLOOP
#undef DOLOOP
#endif
#define DOLOOP for (k = 0, pointer = arr[0]; k < narr; pointer = arr[++k])

namespace {
   static void PrintCR(int j,Int_t aleng, UInt_t ltype)
   {
      if (j == aleng-1) printf("\n");
      else {
         printf(", ");
         if (j%ltype == ltype-1) printf("\n                    ");
      }
   }
}

//______________________________________________________________________________
void TStreamerInfo::PrintValueAux(char *ladd, Int_t atype, TStreamerElement *aElement, Int_t aleng, Int_t *count)
{
   //  print value of element  in object at pointer, type atype, leng aleng or *count
   //  The function may be called in two ways:
   //    -method1  len < 0
   //           i is assumed to be the TStreamerElement number i in StreamerInfo
   //    -method2  len >= 0
   //           i is the type
   //           address of variable is directly pointer.
   //           len is the number of elements to be printed starting at pointer.
   int j;

   //assert(!((kOffsetP + kChar) <= atype && atype <= (kOffsetP + kBool) && count == 0));
   switch (atype) {
      // basic types
      case kBool:              {Bool_t    *val = (Bool_t*   )ladd; printf("%d" ,*val);  break;}
      case kChar:              {Char_t    *val = (Char_t*   )ladd; printf("%d" ,*val);  break;}
      case kShort:             {Short_t   *val = (Short_t*  )ladd; printf("%d" ,*val);  break;}
      case kInt:               {Int_t     *val = (Int_t*    )ladd; printf("%d" ,*val);  break;}
      case kLong:              {Long_t    *val = (Long_t*   )ladd; printf("%ld",*val);  break;}
      case kLong64:            {Long64_t  *val = (Long64_t* )ladd; printf("%lld",*val);  break;}
      case kFloat:             {Float_t   *val = (Float_t*  )ladd; printf("%f" ,*val);  break;}
      case kFloat16:           {Float_t   *val = (Float_t*  )ladd; printf("%f" ,*val);  break;}
      case kDouble:            {Double_t  *val = (Double_t* )ladd; printf("%g" ,*val);  break;}
      case kDouble32:          {Double_t  *val = (Double_t* )ladd; printf("%g" ,*val);  break;}
      case kUChar:             {UChar_t   *val = (UChar_t*  )ladd; printf("%u" ,*val);  break;}
      case kUShort:            {UShort_t  *val = (UShort_t* )ladd; printf("%u" ,*val);  break;}
      case kUInt:              {UInt_t    *val = (UInt_t*   )ladd; printf("%u" ,*val);  break;}
      case kULong:             {ULong_t   *val = (ULong_t*  )ladd; printf("%lu",*val);  break;}
      case kULong64:           {ULong64_t *val = (ULong64_t*)ladd; printf("%llu",*val);  break;}
      case kBits:              {UInt_t    *val = (UInt_t*   )ladd; printf("%d" ,*val);  break;}

         // array of basic types  array[8]
      case kOffsetL + kBool:    {Bool_t    *val = (Bool_t*   )ladd; for(j=0;j<aleng;j++) { printf("%c " ,val[j]); PrintCR(j,aleng,20); } break;}
      case kOffsetL + kChar:    {Char_t    *val = (Char_t*   )ladd; for(j=0;j<aleng;j++) { printf("%c " ,val[j]); PrintCR(j,aleng,20); } break;}
      case kOffsetL + kShort:   {Short_t   *val = (Short_t*  )ladd; for(j=0;j<aleng;j++) { printf("%d " ,val[j]); PrintCR(j,aleng,10); } break;}
      case kOffsetL + kInt:     {Int_t     *val = (Int_t*    )ladd; for(j=0;j<aleng;j++) { printf("%d " ,val[j]); PrintCR(j,aleng,10); } break;}
      case kOffsetL + kLong:    {Long_t    *val = (Long_t*   )ladd; for(j=0;j<aleng;j++) { printf("%ld ",val[j]); PrintCR(j,aleng, 5); } break;}
      case kOffsetL + kLong64:  {Long64_t  *val = (Long64_t* )ladd; for(j=0;j<aleng;j++) { printf("%lld ",val[j]);PrintCR(j,aleng, 5); } break;}
      case kOffsetL + kFloat:   {Float_t   *val = (Float_t*  )ladd; for(j=0;j<aleng;j++) { printf("%f " ,val[j]); PrintCR(j,aleng, 5); } break;}
      case kOffsetL + kFloat16: {Float_t   *val = (Float_t*  )ladd; for(j=0;j<aleng;j++) { printf("%f " ,val[j]); PrintCR(j,aleng, 5); } break;}
      case kOffsetL + kDouble:  {Double_t  *val = (Double_t* )ladd; for(j=0;j<aleng;j++) { printf("%g " ,val[j]); PrintCR(j,aleng, 5); } break;}
      case kOffsetL + kDouble32:{Double_t  *val = (Double_t* )ladd; for(j=0;j<aleng;j++) { printf("%g " ,val[j]); PrintCR(j,aleng, 5); } break;}
      case kOffsetL + kUChar:   {UChar_t   *val = (UChar_t*  )ladd; for(j=0;j<aleng;j++) { printf("%u " ,val[j]); PrintCR(j,aleng,20); } break;}
      case kOffsetL + kUShort:  {UShort_t  *val = (UShort_t* )ladd; for(j=0;j<aleng;j++) { printf("%u " ,val[j]); PrintCR(j,aleng,10); } break;}
      case kOffsetL + kUInt:    {UInt_t    *val = (UInt_t*   )ladd; for(j=0;j<aleng;j++) { printf("%u " ,val[j]); PrintCR(j,aleng, 5); } break;}
      case kOffsetL + kULong:   {ULong_t   *val = (ULong_t*  )ladd; for(j=0;j<aleng;j++) { printf("%lu ",val[j]); PrintCR(j,aleng, 5); } break;}
      case kOffsetL + kULong64: {ULong64_t *val = (ULong64_t*)ladd; for(j=0;j<aleng;j++) { printf("%llu ",val[j]);PrintCR(j,aleng, 5); } break;}
      case kOffsetL + kBits:    {UInt_t    *val = (UInt_t*   )ladd; for(j=0;j<aleng;j++) { printf("%d " ,val[j]); PrintCR(j,aleng, 5); } break;}

         // pointer to an array of basic types  array[n]
      case kOffsetP + kBool:    {Bool_t   **val = (Bool_t**  )ladd; for(j=0;j<*count;j++) { printf("%d " ,(*val)[j]);  PrintCR(j,aleng,20); } break;}
      case kOffsetP + kChar:    {Char_t   **val = (Char_t**  )ladd; for(j=0;j<*count;j++) { printf("%d " ,(*val)[j]);  PrintCR(j,aleng,20); } break;}
      case kOffsetP + kShort:   {Short_t  **val = (Short_t** )ladd; for(j=0;j<*count;j++) { printf("%d " ,(*val)[j]);  PrintCR(j,aleng,10); } break;}
      case kOffsetP + kInt:     {Int_t    **val = (Int_t**   )ladd; for(j=0;j<*count;j++) { printf("%d " ,(*val)[j]);  PrintCR(j,aleng,10); } break;}
      case kOffsetP + kLong:    {Long_t   **val = (Long_t**  )ladd; for(j=0;j<*count;j++) { printf("%ld ",(*val)[j]);  PrintCR(j,aleng, 5); } break;}
      case kOffsetP + kLong64:  {Long64_t **val = (Long64_t**)ladd; for(j=0;j<*count;j++) { printf("%lld ",(*val)[j]); PrintCR(j,aleng, 5); } break;}
      case kOffsetP + kFloat:   {Float_t  **val = (Float_t** )ladd; for(j=0;j<*count;j++) { printf("%f " ,(*val)[j]);  PrintCR(j,aleng, 5); } break;}
      case kOffsetP + kFloat16: {Float_t  **val = (Float_t** )ladd; for(j=0;j<*count;j++) { printf("%f " ,(*val)[j]);  PrintCR(j,aleng, 5); } break;}
      case kOffsetP + kDouble:  {Double_t **val = (Double_t**)ladd; for(j=0;j<*count;j++) { printf("%g " ,(*val)[j]);  PrintCR(j,aleng, 5); } break;}
      case kOffsetP + kDouble32:{Double_t **val = (Double_t**)ladd; for(j=0;j<*count;j++) { printf("%g " ,(*val)[j]);  PrintCR(j,aleng, 5); } break;}
      case kOffsetP + kUChar:   {UChar_t  **val = (UChar_t** )ladd; for(j=0;j<*count;j++) { printf("%u " ,(*val)[j]);  PrintCR(j,aleng,20); } break;}
      case kOffsetP + kUShort:  {UShort_t **val = (UShort_t**)ladd; for(j=0;j<*count;j++) { printf("%u " ,(*val)[j]);  PrintCR(j,aleng,10); } break;}
      case kOffsetP + kUInt:    {UInt_t   **val = (UInt_t**  )ladd; for(j=0;j<*count;j++) { printf("%u " ,(*val)[j]);  PrintCR(j,aleng, 5); } break;}
      case kOffsetP + kULong:   {ULong_t  **val = (ULong_t** )ladd; for(j=0;j<*count;j++) { printf("%lu ",(*val)[j]);  PrintCR(j,aleng, 5); } break;}
      case kOffsetP + kULong64: {ULong64_t**val = (ULong64_t**)ladd; for(j=0;j<*count;j++){ printf("%llu ",(*val)[j]); PrintCR(j,aleng, 5); } break;}

         // array counter //[n]
      case kCounter:            {Int_t *val    = (Int_t*)ladd;    printf("%d",*val);  break;}
         // char *
      case kCharStar:{
         char **val = (char**)ladd;
         if (*val) printf("%s",*val);
         break;
      }
      // Class *  derived from TObject with comment field  //->
      case kObjectp: {
         TObject **obj = (TObject**)(ladd);
         TStreamerObjectPointer *el = (TStreamerObjectPointer*)aElement;
         printf("(%s*)%lx",el ? el->GetClass()->GetName() : "unknown_type",(Long_t)(*obj));
         break;
      }

      // Class*   derived from TObject
      case kObjectP: {
         TObject **obj = (TObject**)(ladd);
         TStreamerObjectPointer *el = (TStreamerObjectPointer*)aElement;
         printf("(%s*)%lx",el ? el->GetClass()->GetName() : "unknown_type",(Long_t)(*obj));
         break;
      }

      // Class    derived from TObject
      case kObject:  {
         TObject *obj = (TObject*)(ladd);
         printf("%s",obj->GetName());
         break;
      }

      // Special case for TString, TObject, TNamed
      case kTString: {
         TString *st = (TString*)(ladd);
         printf("%s",st->Data());
         break;
      }
      case kTObject: {
         TObject *obj = (TObject*)(ladd);
         printf("%s",obj->GetName());
         break;
      }
      case kTNamed:  {
         TNamed *named = (TNamed*) (ladd);
         printf("%s/%s",named->GetName(),named->GetTitle());
         break;
      }

      // Class *  not derived from TObject with comment field  //->
      case kAnyp:    {
         TObject **obj = (TObject**)(ladd);
         TStreamerObjectAnyPointer *el = (TStreamerObjectAnyPointer*)aElement;
         printf("(%s*)0x%lx",el ? el->GetClass()->GetName() : "unknown_type",(Long_t)(*obj));
         break;
      }

      // Class*   not derived from TObject
      case kAnyP:    {
         TObject **obj = (TObject**)(ladd);
         TStreamerObjectAnyPointer *el = (TStreamerObjectAnyPointer*)aElement;
         printf("(%s*)0x%lx",el ? el->GetClass()->GetName() : "unknown_type",(Long_t)(*obj));
         break;
      }
      // Any Class not derived from TObject
      case kOffsetL + kObjectp:
      case kOffsetL + kObjectP:
      case kAny:     {
         printf("printing kAny case (%d)",atype);
//         if (aElement) {
//            TMemberStreamer *pstreamer = aElement->GetStreamer();
//            if (pstreamer == 0) {
//               //printf("ERROR, Streamer is null\n");
//               //aElement->ls();
//               break;
//            }
//            //(*pstreamer)(b,ladd,0);
//         }
         break;
      }
      // Base Class
      case kBase:    {
         printf("printing kBase case (%d)",atype);
         //aElement->ReadBuffer(b,pointer);
         break;
      }

      case kOffsetL + kObject:
      case kOffsetL + kTString:
      case kOffsetL + kTObject:
      case kOffsetL + kTNamed:
      case kStreamer: {
         printf("printing kStreamer case (%d)",atype);
//         TMemberStreamer *pstreamer = aElement->GetStreamer();
//         if (pstreamer == 0) {
//            //printf("ERROR, Streamer is null\n");
//            //aElement->ls();
//            break;
//         }
//         //UInt_t start,count;
//         //b.ReadVersion(&start, &count);
//         //(*pstreamer)(b,ladd,0);
//         //b.CheckByteCount(start,count,IsA());
         break;
      }

      case kStreamLoop: {
         printf("printing kStreamLoop case (%d)",atype);
//         TMemberStreamer *pstreamer = aElement->GetStreamer();
//         if (pstreamer == 0) {
//            //printf("ERROR, Streamer is null\n");
//            //aElement->ls();
//            break;
//         }
         //Int_t *counter = (Int_t*)(count);
         //UInt_t start,count;
         ///b.ReadVersion(&start, &count);
         //(*pstreamer)(b,ladd,*counter);
         //b.CheckByteCount(start,count,IsA());
         break;
      }
      case kSTL: {
         if (aElement) {
            static TClassRef stringClass("string");
            if (ladd && aElement->GetClass() == stringClass) {
               std::string *st = (std::string*)(ladd);
               printf("%s",st->c_str());
            } else {
               printf("(%s*)0x%lx",aElement->GetClass()->GetName(),(Long_t)(ladd));
            }
         } else {
            printf("(unknown_type*)0x%lx",(Long_t)(ladd));
         }
         break;
      }
   }
}

//______________________________________________________________________________
void TStreamerInfo::Update(const TClass *oldcl, TClass *newcl)
{
   //function called by the TClass constructor when replacing an emulated class
   //by the real class

   TStreamerElement *element;
   TIter nextElement(GetElements());
   while ((element = (TStreamerElement*)nextElement())) {
      element->Update(oldcl,newcl);
   }
   for (Int_t i=0;i < fNslots;i++) {
      fComp[i].Update(oldcl,newcl);
   }
}

//______________________________________________________________________________
void TStreamerInfo::TCompInfo::Update(const TClass *oldcl, TClass *newcl)
{
   // Update the TClass pointer cached in this object.

   if (fType != -1) {
      if (fClass == oldcl)
         fClass = newcl;
      else if (fClass == 0)
         fClass = TClass::GetClass(fClassName);
   }
}


//______________________________________________________________________________
//______________________________________________________________________________

//______________________________________________________________________________
TVirtualCollectionProxy*
TStreamerInfo::GenEmulatedProxy(const char* class_name, Bool_t silent)
{
   // Generate emulated collection proxy for a given class.

   return TCollectionProxyFactory::GenEmulatedProxy(class_name, silent);
}

//______________________________________________________________________________
TClassStreamer*
TStreamerInfo::GenEmulatedClassStreamer(const char* class_name, Bool_t silent)
{
   // Generate emulated class streamer for a given collection class.

   return TCollectionProxyFactory::GenEmulatedClassStreamer(class_name, silent);
}

//______________________________________________________________________________
TVirtualCollectionProxy*
TStreamerInfo::GenExplicitProxy( const ::ROOT::TCollectionProxyInfo &info, TClass *cl )
{
   // Generate proxy from static functions.

   return TCollectionProxyFactory::GenExplicitProxy(info, cl);
}

//______________________________________________________________________________
TClassStreamer*
TStreamerInfo::GenExplicitClassStreamer( const ::ROOT::TCollectionProxyInfo &info, TClass *cl )
{
   // Generate class streamer from static functions.

   return TCollectionProxyFactory::GenExplicitClassStreamer(info, cl);
}
 TStreamerInfo.cxx:1
 TStreamerInfo.cxx:2
 TStreamerInfo.cxx:3
 TStreamerInfo.cxx:4
 TStreamerInfo.cxx:5
 TStreamerInfo.cxx:6
 TStreamerInfo.cxx:7
 TStreamerInfo.cxx:8
 TStreamerInfo.cxx:9
 TStreamerInfo.cxx:10
 TStreamerInfo.cxx:11
 TStreamerInfo.cxx:12
 TStreamerInfo.cxx:13
 TStreamerInfo.cxx:14
 TStreamerInfo.cxx:15
 TStreamerInfo.cxx:16
 TStreamerInfo.cxx:17
 TStreamerInfo.cxx:18
 TStreamerInfo.cxx:19
 TStreamerInfo.cxx:20
 TStreamerInfo.cxx:21
 TStreamerInfo.cxx:22
 TStreamerInfo.cxx:23
 TStreamerInfo.cxx:24
 TStreamerInfo.cxx:25
 TStreamerInfo.cxx:26
 TStreamerInfo.cxx:27
 TStreamerInfo.cxx:28
 TStreamerInfo.cxx:29
 TStreamerInfo.cxx:30
 TStreamerInfo.cxx:31
 TStreamerInfo.cxx:32
 TStreamerInfo.cxx:33
 TStreamerInfo.cxx:34
 TStreamerInfo.cxx:35
 TStreamerInfo.cxx:36
 TStreamerInfo.cxx:37
 TStreamerInfo.cxx:38
 TStreamerInfo.cxx:39
 TStreamerInfo.cxx:40
 TStreamerInfo.cxx:41
 TStreamerInfo.cxx:42
 TStreamerInfo.cxx:43
 TStreamerInfo.cxx:44
 TStreamerInfo.cxx:45
 TStreamerInfo.cxx:46
 TStreamerInfo.cxx:47
 TStreamerInfo.cxx:48
 TStreamerInfo.cxx:49
 TStreamerInfo.cxx:50
 TStreamerInfo.cxx:51
 TStreamerInfo.cxx:52
 TStreamerInfo.cxx:53
 TStreamerInfo.cxx:54
 TStreamerInfo.cxx:55
 TStreamerInfo.cxx:56
 TStreamerInfo.cxx:57
 TStreamerInfo.cxx:58
 TStreamerInfo.cxx:59
 TStreamerInfo.cxx:60
 TStreamerInfo.cxx:61
 TStreamerInfo.cxx:62
 TStreamerInfo.cxx:63
 TStreamerInfo.cxx:64
 TStreamerInfo.cxx:65
 TStreamerInfo.cxx:66
 TStreamerInfo.cxx:67
 TStreamerInfo.cxx:68
 TStreamerInfo.cxx:69
 TStreamerInfo.cxx:70
 TStreamerInfo.cxx:71
 TStreamerInfo.cxx:72
 TStreamerInfo.cxx:73
 TStreamerInfo.cxx:74
 TStreamerInfo.cxx:75
 TStreamerInfo.cxx:76
 TStreamerInfo.cxx:77
 TStreamerInfo.cxx:78
 TStreamerInfo.cxx:79
 TStreamerInfo.cxx:80
 TStreamerInfo.cxx:81
 TStreamerInfo.cxx:82
 TStreamerInfo.cxx:83
 TStreamerInfo.cxx:84
 TStreamerInfo.cxx:85
 TStreamerInfo.cxx:86
 TStreamerInfo.cxx:87
 TStreamerInfo.cxx:88
 TStreamerInfo.cxx:89
 TStreamerInfo.cxx:90
 TStreamerInfo.cxx:91
 TStreamerInfo.cxx:92
 TStreamerInfo.cxx:93
 TStreamerInfo.cxx:94
 TStreamerInfo.cxx:95
 TStreamerInfo.cxx:96
 TStreamerInfo.cxx:97
 TStreamerInfo.cxx:98
 TStreamerInfo.cxx:99
 TStreamerInfo.cxx:100
 TStreamerInfo.cxx:101
 TStreamerInfo.cxx:102
 TStreamerInfo.cxx:103
 TStreamerInfo.cxx:104
 TStreamerInfo.cxx:105
 TStreamerInfo.cxx:106
 TStreamerInfo.cxx:107
 TStreamerInfo.cxx:108
 TStreamerInfo.cxx:109
 TStreamerInfo.cxx:110
 TStreamerInfo.cxx:111
 TStreamerInfo.cxx:112
 TStreamerInfo.cxx:113
 TStreamerInfo.cxx:114
 TStreamerInfo.cxx:115
 TStreamerInfo.cxx:116
 TStreamerInfo.cxx:117
 TStreamerInfo.cxx:118
 TStreamerInfo.cxx:119
 TStreamerInfo.cxx:120
 TStreamerInfo.cxx:121
 TStreamerInfo.cxx:122
 TStreamerInfo.cxx:123
 TStreamerInfo.cxx:124
 TStreamerInfo.cxx:125
 TStreamerInfo.cxx:126
 TStreamerInfo.cxx:127
 TStreamerInfo.cxx:128
 TStreamerInfo.cxx:129
 TStreamerInfo.cxx:130
 TStreamerInfo.cxx:131
 TStreamerInfo.cxx:132
 TStreamerInfo.cxx:133
 TStreamerInfo.cxx:134
 TStreamerInfo.cxx:135
 TStreamerInfo.cxx:136
 TStreamerInfo.cxx:137
 TStreamerInfo.cxx:138
 TStreamerInfo.cxx:139
 TStreamerInfo.cxx:140
 TStreamerInfo.cxx:141
 TStreamerInfo.cxx:142
 TStreamerInfo.cxx:143
 TStreamerInfo.cxx:144
 TStreamerInfo.cxx:145
 TStreamerInfo.cxx:146
 TStreamerInfo.cxx:147
 TStreamerInfo.cxx:148
 TStreamerInfo.cxx:149
 TStreamerInfo.cxx:150
 TStreamerInfo.cxx:151
 TStreamerInfo.cxx:152
 TStreamerInfo.cxx:153
 TStreamerInfo.cxx:154
 TStreamerInfo.cxx:155
 TStreamerInfo.cxx:156
 TStreamerInfo.cxx:157
 TStreamerInfo.cxx:158
 TStreamerInfo.cxx:159
 TStreamerInfo.cxx:160
 TStreamerInfo.cxx:161
 TStreamerInfo.cxx:162
 TStreamerInfo.cxx:163
 TStreamerInfo.cxx:164
 TStreamerInfo.cxx:165
 TStreamerInfo.cxx:166
 TStreamerInfo.cxx:167
 TStreamerInfo.cxx:168
 TStreamerInfo.cxx:169
 TStreamerInfo.cxx:170
 TStreamerInfo.cxx:171
 TStreamerInfo.cxx:172
 TStreamerInfo.cxx:173
 TStreamerInfo.cxx:174
 TStreamerInfo.cxx:175
 TStreamerInfo.cxx:176
 TStreamerInfo.cxx:177
 TStreamerInfo.cxx:178
 TStreamerInfo.cxx:179
 TStreamerInfo.cxx:180
 TStreamerInfo.cxx:181
 TStreamerInfo.cxx:182
 TStreamerInfo.cxx:183
 TStreamerInfo.cxx:184
 TStreamerInfo.cxx:185
 TStreamerInfo.cxx:186
 TStreamerInfo.cxx:187
 TStreamerInfo.cxx:188
 TStreamerInfo.cxx:189
 TStreamerInfo.cxx:190
 TStreamerInfo.cxx:191
 TStreamerInfo.cxx:192
 TStreamerInfo.cxx:193
 TStreamerInfo.cxx:194
 TStreamerInfo.cxx:195
 TStreamerInfo.cxx:196
 TStreamerInfo.cxx:197
 TStreamerInfo.cxx:198
 TStreamerInfo.cxx:199
 TStreamerInfo.cxx:200
 TStreamerInfo.cxx:201
 TStreamerInfo.cxx:202
 TStreamerInfo.cxx:203
 TStreamerInfo.cxx:204
 TStreamerInfo.cxx:205
 TStreamerInfo.cxx:206
 TStreamerInfo.cxx:207
 TStreamerInfo.cxx:208
 TStreamerInfo.cxx:209
 TStreamerInfo.cxx:210
 TStreamerInfo.cxx:211
 TStreamerInfo.cxx:212
 TStreamerInfo.cxx:213
 TStreamerInfo.cxx:214
 TStreamerInfo.cxx:215
 TStreamerInfo.cxx:216
 TStreamerInfo.cxx:217
 TStreamerInfo.cxx:218
 TStreamerInfo.cxx:219
 TStreamerInfo.cxx:220
 TStreamerInfo.cxx:221
 TStreamerInfo.cxx:222
 TStreamerInfo.cxx:223
 TStreamerInfo.cxx:224
 TStreamerInfo.cxx:225
 TStreamerInfo.cxx:226
 TStreamerInfo.cxx:227
 TStreamerInfo.cxx:228
 TStreamerInfo.cxx:229
 TStreamerInfo.cxx:230
 TStreamerInfo.cxx:231
 TStreamerInfo.cxx:232
 TStreamerInfo.cxx:233
 TStreamerInfo.cxx:234
 TStreamerInfo.cxx:235
 TStreamerInfo.cxx:236
 TStreamerInfo.cxx:237
 TStreamerInfo.cxx:238
 TStreamerInfo.cxx:239
 TStreamerInfo.cxx:240
 TStreamerInfo.cxx:241
 TStreamerInfo.cxx:242
 TStreamerInfo.cxx:243
 TStreamerInfo.cxx:244
 TStreamerInfo.cxx:245
 TStreamerInfo.cxx:246
 TStreamerInfo.cxx:247
 TStreamerInfo.cxx:248
 TStreamerInfo.cxx:249
 TStreamerInfo.cxx:250
 TStreamerInfo.cxx:251
 TStreamerInfo.cxx:252
 TStreamerInfo.cxx:253
 TStreamerInfo.cxx:254
 TStreamerInfo.cxx:255
 TStreamerInfo.cxx:256
 TStreamerInfo.cxx:257
 TStreamerInfo.cxx:258
 TStreamerInfo.cxx:259
 TStreamerInfo.cxx:260
 TStreamerInfo.cxx:261
 TStreamerInfo.cxx:262
 TStreamerInfo.cxx:263
 TStreamerInfo.cxx:264
 TStreamerInfo.cxx:265
 TStreamerInfo.cxx:266
 TStreamerInfo.cxx:267
 TStreamerInfo.cxx:268
 TStreamerInfo.cxx:269
 TStreamerInfo.cxx:270
 TStreamerInfo.cxx:271
 TStreamerInfo.cxx:272
 TStreamerInfo.cxx:273
 TStreamerInfo.cxx:274
 TStreamerInfo.cxx:275
 TStreamerInfo.cxx:276
 TStreamerInfo.cxx:277
 TStreamerInfo.cxx:278
 TStreamerInfo.cxx:279
 TStreamerInfo.cxx:280
 TStreamerInfo.cxx:281
 TStreamerInfo.cxx:282
 TStreamerInfo.cxx:283
 TStreamerInfo.cxx:284
 TStreamerInfo.cxx:285
 TStreamerInfo.cxx:286
 TStreamerInfo.cxx:287
 TStreamerInfo.cxx:288
 TStreamerInfo.cxx:289
 TStreamerInfo.cxx:290
 TStreamerInfo.cxx:291
 TStreamerInfo.cxx:292
 TStreamerInfo.cxx:293
 TStreamerInfo.cxx:294
 TStreamerInfo.cxx:295
 TStreamerInfo.cxx:296
 TStreamerInfo.cxx:297
 TStreamerInfo.cxx:298
 TStreamerInfo.cxx:299
 TStreamerInfo.cxx:300
 TStreamerInfo.cxx:301
 TStreamerInfo.cxx:302
 TStreamerInfo.cxx:303
 TStreamerInfo.cxx:304
 TStreamerInfo.cxx:305
 TStreamerInfo.cxx:306
 TStreamerInfo.cxx:307
 TStreamerInfo.cxx:308
 TStreamerInfo.cxx:309
 TStreamerInfo.cxx:310
 TStreamerInfo.cxx:311
 TStreamerInfo.cxx:312
 TStreamerInfo.cxx:313
 TStreamerInfo.cxx:314
 TStreamerInfo.cxx:315
 TStreamerInfo.cxx:316
 TStreamerInfo.cxx:317
 TStreamerInfo.cxx:318
 TStreamerInfo.cxx:319
 TStreamerInfo.cxx:320
 TStreamerInfo.cxx:321
 TStreamerInfo.cxx:322
 TStreamerInfo.cxx:323
 TStreamerInfo.cxx:324
 TStreamerInfo.cxx:325
 TStreamerInfo.cxx:326
 TStreamerInfo.cxx:327
 TStreamerInfo.cxx:328
 TStreamerInfo.cxx:329
 TStreamerInfo.cxx:330
 TStreamerInfo.cxx:331
 TStreamerInfo.cxx:332
 TStreamerInfo.cxx:333
 TStreamerInfo.cxx:334
 TStreamerInfo.cxx:335
 TStreamerInfo.cxx:336
 TStreamerInfo.cxx:337
 TStreamerInfo.cxx:338
 TStreamerInfo.cxx:339
 TStreamerInfo.cxx:340
 TStreamerInfo.cxx:341
 TStreamerInfo.cxx:342
 TStreamerInfo.cxx:343
 TStreamerInfo.cxx:344
 TStreamerInfo.cxx:345
 TStreamerInfo.cxx:346
 TStreamerInfo.cxx:347
 TStreamerInfo.cxx:348
 TStreamerInfo.cxx:349
 TStreamerInfo.cxx:350
 TStreamerInfo.cxx:351
 TStreamerInfo.cxx:352
 TStreamerInfo.cxx:353
 TStreamerInfo.cxx:354
 TStreamerInfo.cxx:355
 TStreamerInfo.cxx:356
 TStreamerInfo.cxx:357
 TStreamerInfo.cxx:358
 TStreamerInfo.cxx:359
 TStreamerInfo.cxx:360
 TStreamerInfo.cxx:361
 TStreamerInfo.cxx:362
 TStreamerInfo.cxx:363
 TStreamerInfo.cxx:364
 TStreamerInfo.cxx:365
 TStreamerInfo.cxx:366
 TStreamerInfo.cxx:367
 TStreamerInfo.cxx:368
 TStreamerInfo.cxx:369
 TStreamerInfo.cxx:370
 TStreamerInfo.cxx:371
 TStreamerInfo.cxx:372
 TStreamerInfo.cxx:373
 TStreamerInfo.cxx:374
 TStreamerInfo.cxx:375
 TStreamerInfo.cxx:376
 TStreamerInfo.cxx:377
 TStreamerInfo.cxx:378
 TStreamerInfo.cxx:379
 TStreamerInfo.cxx:380
 TStreamerInfo.cxx:381
 TStreamerInfo.cxx:382
 TStreamerInfo.cxx:383
 TStreamerInfo.cxx:384
 TStreamerInfo.cxx:385
 TStreamerInfo.cxx:386
 TStreamerInfo.cxx:387
 TStreamerInfo.cxx:388
 TStreamerInfo.cxx:389
 TStreamerInfo.cxx:390
 TStreamerInfo.cxx:391
 TStreamerInfo.cxx:392
 TStreamerInfo.cxx:393
 TStreamerInfo.cxx:394
 TStreamerInfo.cxx:395
 TStreamerInfo.cxx:396
 TStreamerInfo.cxx:397
 TStreamerInfo.cxx:398
 TStreamerInfo.cxx:399
 TStreamerInfo.cxx:400
 TStreamerInfo.cxx:401
 TStreamerInfo.cxx:402
 TStreamerInfo.cxx:403
 TStreamerInfo.cxx:404
 TStreamerInfo.cxx:405
 TStreamerInfo.cxx:406
 TStreamerInfo.cxx:407
 TStreamerInfo.cxx:408
 TStreamerInfo.cxx:409
 TStreamerInfo.cxx:410
 TStreamerInfo.cxx:411
 TStreamerInfo.cxx:412
 TStreamerInfo.cxx:413
 TStreamerInfo.cxx:414
 TStreamerInfo.cxx:415
 TStreamerInfo.cxx:416
 TStreamerInfo.cxx:417
 TStreamerInfo.cxx:418
 TStreamerInfo.cxx:419
 TStreamerInfo.cxx:420
 TStreamerInfo.cxx:421
 TStreamerInfo.cxx:422
 TStreamerInfo.cxx:423
 TStreamerInfo.cxx:424
 TStreamerInfo.cxx:425
 TStreamerInfo.cxx:426
 TStreamerInfo.cxx:427
 TStreamerInfo.cxx:428
 TStreamerInfo.cxx:429
 TStreamerInfo.cxx:430
 TStreamerInfo.cxx:431
 TStreamerInfo.cxx:432
 TStreamerInfo.cxx:433
 TStreamerInfo.cxx:434
 TStreamerInfo.cxx:435
 TStreamerInfo.cxx:436
 TStreamerInfo.cxx:437
 TStreamerInfo.cxx:438
 TStreamerInfo.cxx:439
 TStreamerInfo.cxx:440
 TStreamerInfo.cxx:441
 TStreamerInfo.cxx:442
 TStreamerInfo.cxx:443
 TStreamerInfo.cxx:444
 TStreamerInfo.cxx:445
 TStreamerInfo.cxx:446
 TStreamerInfo.cxx:447
 TStreamerInfo.cxx:448
 TStreamerInfo.cxx:449
 TStreamerInfo.cxx:450
 TStreamerInfo.cxx:451
 TStreamerInfo.cxx:452
 TStreamerInfo.cxx:453
 TStreamerInfo.cxx:454
 TStreamerInfo.cxx:455
 TStreamerInfo.cxx:456
 TStreamerInfo.cxx:457
 TStreamerInfo.cxx:458
 TStreamerInfo.cxx:459
 TStreamerInfo.cxx:460
 TStreamerInfo.cxx:461
 TStreamerInfo.cxx:462
 TStreamerInfo.cxx:463
 TStreamerInfo.cxx:464
 TStreamerInfo.cxx:465
 TStreamerInfo.cxx:466
 TStreamerInfo.cxx:467
 TStreamerInfo.cxx:468
 TStreamerInfo.cxx:469
 TStreamerInfo.cxx:470
 TStreamerInfo.cxx:471
 TStreamerInfo.cxx:472
 TStreamerInfo.cxx:473
 TStreamerInfo.cxx:474
 TStreamerInfo.cxx:475
 TStreamerInfo.cxx:476
 TStreamerInfo.cxx:477
 TStreamerInfo.cxx:478
 TStreamerInfo.cxx:479
 TStreamerInfo.cxx:480
 TStreamerInfo.cxx:481
 TStreamerInfo.cxx:482
 TStreamerInfo.cxx:483
 TStreamerInfo.cxx:484
 TStreamerInfo.cxx:485
 TStreamerInfo.cxx:486
 TStreamerInfo.cxx:487
 TStreamerInfo.cxx:488
 TStreamerInfo.cxx:489
 TStreamerInfo.cxx:490
 TStreamerInfo.cxx:491
 TStreamerInfo.cxx:492
 TStreamerInfo.cxx:493
 TStreamerInfo.cxx:494
 TStreamerInfo.cxx:495
 TStreamerInfo.cxx:496
 TStreamerInfo.cxx:497
 TStreamerInfo.cxx:498
 TStreamerInfo.cxx:499
 TStreamerInfo.cxx:500
 TStreamerInfo.cxx:501
 TStreamerInfo.cxx:502
 TStreamerInfo.cxx:503
 TStreamerInfo.cxx:504
 TStreamerInfo.cxx:505
 TStreamerInfo.cxx:506
 TStreamerInfo.cxx:507
 TStreamerInfo.cxx:508
 TStreamerInfo.cxx:509
 TStreamerInfo.cxx:510
 TStreamerInfo.cxx:511
 TStreamerInfo.cxx:512
 TStreamerInfo.cxx:513
 TStreamerInfo.cxx:514
 TStreamerInfo.cxx:515
 TStreamerInfo.cxx:516
 TStreamerInfo.cxx:517
 TStreamerInfo.cxx:518
 TStreamerInfo.cxx:519
 TStreamerInfo.cxx:520
 TStreamerInfo.cxx:521
 TStreamerInfo.cxx:522
 TStreamerInfo.cxx:523
 TStreamerInfo.cxx:524
 TStreamerInfo.cxx:525
 TStreamerInfo.cxx:526
 TStreamerInfo.cxx:527
 TStreamerInfo.cxx:528
 TStreamerInfo.cxx:529
 TStreamerInfo.cxx:530
 TStreamerInfo.cxx:531
 TStreamerInfo.cxx:532
 TStreamerInfo.cxx:533
 TStreamerInfo.cxx:534
 TStreamerInfo.cxx:535
 TStreamerInfo.cxx:536
 TStreamerInfo.cxx:537
 TStreamerInfo.cxx:538
 TStreamerInfo.cxx:539
 TStreamerInfo.cxx:540
 TStreamerInfo.cxx:541
 TStreamerInfo.cxx:542
 TStreamerInfo.cxx:543
 TStreamerInfo.cxx:544
 TStreamerInfo.cxx:545
 TStreamerInfo.cxx:546
 TStreamerInfo.cxx:547
 TStreamerInfo.cxx:548
 TStreamerInfo.cxx:549
 TStreamerInfo.cxx:550
 TStreamerInfo.cxx:551
 TStreamerInfo.cxx:552
 TStreamerInfo.cxx:553
 TStreamerInfo.cxx:554
 TStreamerInfo.cxx:555
 TStreamerInfo.cxx:556
 TStreamerInfo.cxx:557
 TStreamerInfo.cxx:558
 TStreamerInfo.cxx:559
 TStreamerInfo.cxx:560
 TStreamerInfo.cxx:561
 TStreamerInfo.cxx:562
 TStreamerInfo.cxx:563
 TStreamerInfo.cxx:564
 TStreamerInfo.cxx:565
 TStreamerInfo.cxx:566
 TStreamerInfo.cxx:567
 TStreamerInfo.cxx:568
 TStreamerInfo.cxx:569
 TStreamerInfo.cxx:570
 TStreamerInfo.cxx:571
 TStreamerInfo.cxx:572
 TStreamerInfo.cxx:573
 TStreamerInfo.cxx:574
 TStreamerInfo.cxx:575
 TStreamerInfo.cxx:576
 TStreamerInfo.cxx:577
 TStreamerInfo.cxx:578
 TStreamerInfo.cxx:579
 TStreamerInfo.cxx:580
 TStreamerInfo.cxx:581
 TStreamerInfo.cxx:582
 TStreamerInfo.cxx:583
 TStreamerInfo.cxx:584
 TStreamerInfo.cxx:585
 TStreamerInfo.cxx:586
 TStreamerInfo.cxx:587
 TStreamerInfo.cxx:588
 TStreamerInfo.cxx:589
 TStreamerInfo.cxx:590
 TStreamerInfo.cxx:591
 TStreamerInfo.cxx:592
 TStreamerInfo.cxx:593
 TStreamerInfo.cxx:594
 TStreamerInfo.cxx:595
 TStreamerInfo.cxx:596
 TStreamerInfo.cxx:597
 TStreamerInfo.cxx:598
 TStreamerInfo.cxx:599
 TStreamerInfo.cxx:600
 TStreamerInfo.cxx:601
 TStreamerInfo.cxx:602
 TStreamerInfo.cxx:603
 TStreamerInfo.cxx:604
 TStreamerInfo.cxx:605
 TStreamerInfo.cxx:606
 TStreamerInfo.cxx:607
 TStreamerInfo.cxx:608
 TStreamerInfo.cxx:609
 TStreamerInfo.cxx:610
 TStreamerInfo.cxx:611
 TStreamerInfo.cxx:612
 TStreamerInfo.cxx:613
 TStreamerInfo.cxx:614
 TStreamerInfo.cxx:615
 TStreamerInfo.cxx:616
 TStreamerInfo.cxx:617
 TStreamerInfo.cxx:618
 TStreamerInfo.cxx:619
 TStreamerInfo.cxx:620
 TStreamerInfo.cxx:621
 TStreamerInfo.cxx:622
 TStreamerInfo.cxx:623
 TStreamerInfo.cxx:624
 TStreamerInfo.cxx:625
 TStreamerInfo.cxx:626
 TStreamerInfo.cxx:627
 TStreamerInfo.cxx:628
 TStreamerInfo.cxx:629
 TStreamerInfo.cxx:630
 TStreamerInfo.cxx:631
 TStreamerInfo.cxx:632
 TStreamerInfo.cxx:633
 TStreamerInfo.cxx:634
 TStreamerInfo.cxx:635
 TStreamerInfo.cxx:636
 TStreamerInfo.cxx:637
 TStreamerInfo.cxx:638
 TStreamerInfo.cxx:639
 TStreamerInfo.cxx:640
 TStreamerInfo.cxx:641
 TStreamerInfo.cxx:642
 TStreamerInfo.cxx:643
 TStreamerInfo.cxx:644
 TStreamerInfo.cxx:645
 TStreamerInfo.cxx:646
 TStreamerInfo.cxx:647
 TStreamerInfo.cxx:648
 TStreamerInfo.cxx:649
 TStreamerInfo.cxx:650
 TStreamerInfo.cxx:651
 TStreamerInfo.cxx:652
 TStreamerInfo.cxx:653
 TStreamerInfo.cxx:654
 TStreamerInfo.cxx:655
 TStreamerInfo.cxx:656
 TStreamerInfo.cxx:657
 TStreamerInfo.cxx:658
 TStreamerInfo.cxx:659
 TStreamerInfo.cxx:660
 TStreamerInfo.cxx:661
 TStreamerInfo.cxx:662
 TStreamerInfo.cxx:663
 TStreamerInfo.cxx:664
 TStreamerInfo.cxx:665
 TStreamerInfo.cxx:666
 TStreamerInfo.cxx:667
 TStreamerInfo.cxx:668
 TStreamerInfo.cxx:669
 TStreamerInfo.cxx:670
 TStreamerInfo.cxx:671
 TStreamerInfo.cxx:672
 TStreamerInfo.cxx:673
 TStreamerInfo.cxx:674
 TStreamerInfo.cxx:675
 TStreamerInfo.cxx:676
 TStreamerInfo.cxx:677
 TStreamerInfo.cxx:678
 TStreamerInfo.cxx:679
 TStreamerInfo.cxx:680
 TStreamerInfo.cxx:681
 TStreamerInfo.cxx:682
 TStreamerInfo.cxx:683
 TStreamerInfo.cxx:684
 TStreamerInfo.cxx:685
 TStreamerInfo.cxx:686
 TStreamerInfo.cxx:687
 TStreamerInfo.cxx:688
 TStreamerInfo.cxx:689
 TStreamerInfo.cxx:690
 TStreamerInfo.cxx:691
 TStreamerInfo.cxx:692
 TStreamerInfo.cxx:693
 TStreamerInfo.cxx:694
 TStreamerInfo.cxx:695
 TStreamerInfo.cxx:696
 TStreamerInfo.cxx:697
 TStreamerInfo.cxx:698
 TStreamerInfo.cxx:699
 TStreamerInfo.cxx:700
 TStreamerInfo.cxx:701
 TStreamerInfo.cxx:702
 TStreamerInfo.cxx:703
 TStreamerInfo.cxx:704
 TStreamerInfo.cxx:705
 TStreamerInfo.cxx:706
 TStreamerInfo.cxx:707
 TStreamerInfo.cxx:708
 TStreamerInfo.cxx:709
 TStreamerInfo.cxx:710
 TStreamerInfo.cxx:711
 TStreamerInfo.cxx:712
 TStreamerInfo.cxx:713
 TStreamerInfo.cxx:714
 TStreamerInfo.cxx:715
 TStreamerInfo.cxx:716
 TStreamerInfo.cxx:717
 TStreamerInfo.cxx:718
 TStreamerInfo.cxx:719
 TStreamerInfo.cxx:720
 TStreamerInfo.cxx:721
 TStreamerInfo.cxx:722
 TStreamerInfo.cxx:723
 TStreamerInfo.cxx:724
 TStreamerInfo.cxx:725
 TStreamerInfo.cxx:726
 TStreamerInfo.cxx:727
 TStreamerInfo.cxx:728
 TStreamerInfo.cxx:729
 TStreamerInfo.cxx:730
 TStreamerInfo.cxx:731
 TStreamerInfo.cxx:732
 TStreamerInfo.cxx:733
 TStreamerInfo.cxx:734
 TStreamerInfo.cxx:735
 TStreamerInfo.cxx:736
 TStreamerInfo.cxx:737
 TStreamerInfo.cxx:738
 TStreamerInfo.cxx:739
 TStreamerInfo.cxx:740
 TStreamerInfo.cxx:741
 TStreamerInfo.cxx:742
 TStreamerInfo.cxx:743
 TStreamerInfo.cxx:744
 TStreamerInfo.cxx:745
 TStreamerInfo.cxx:746
 TStreamerInfo.cxx:747
 TStreamerInfo.cxx:748
 TStreamerInfo.cxx:749
 TStreamerInfo.cxx:750
 TStreamerInfo.cxx:751
 TStreamerInfo.cxx:752
 TStreamerInfo.cxx:753
 TStreamerInfo.cxx:754
 TStreamerInfo.cxx:755
 TStreamerInfo.cxx:756
 TStreamerInfo.cxx:757
 TStreamerInfo.cxx:758
 TStreamerInfo.cxx:759
 TStreamerInfo.cxx:760
 TStreamerInfo.cxx:761
 TStreamerInfo.cxx:762
 TStreamerInfo.cxx:763
 TStreamerInfo.cxx:764
 TStreamerInfo.cxx:765
 TStreamerInfo.cxx:766
 TStreamerInfo.cxx:767
 TStreamerInfo.cxx:768
 TStreamerInfo.cxx:769
 TStreamerInfo.cxx:770
 TStreamerInfo.cxx:771
 TStreamerInfo.cxx:772
 TStreamerInfo.cxx:773
 TStreamerInfo.cxx:774
 TStreamerInfo.cxx:775
 TStreamerInfo.cxx:776
 TStreamerInfo.cxx:777
 TStreamerInfo.cxx:778
 TStreamerInfo.cxx:779
 TStreamerInfo.cxx:780
 TStreamerInfo.cxx:781
 TStreamerInfo.cxx:782
 TStreamerInfo.cxx:783
 TStreamerInfo.cxx:784
 TStreamerInfo.cxx:785
 TStreamerInfo.cxx:786
 TStreamerInfo.cxx:787
 TStreamerInfo.cxx:788
 TStreamerInfo.cxx:789
 TStreamerInfo.cxx:790
 TStreamerInfo.cxx:791
 TStreamerInfo.cxx:792
 TStreamerInfo.cxx:793
 TStreamerInfo.cxx:794
 TStreamerInfo.cxx:795
 TStreamerInfo.cxx:796
 TStreamerInfo.cxx:797
 TStreamerInfo.cxx:798
 TStreamerInfo.cxx:799
 TStreamerInfo.cxx:800
 TStreamerInfo.cxx:801
 TStreamerInfo.cxx:802
 TStreamerInfo.cxx:803
 TStreamerInfo.cxx:804
 TStreamerInfo.cxx:805
 TStreamerInfo.cxx:806
 TStreamerInfo.cxx:807
 TStreamerInfo.cxx:808
 TStreamerInfo.cxx:809
 TStreamerInfo.cxx:810
 TStreamerInfo.cxx:811
 TStreamerInfo.cxx:812
 TStreamerInfo.cxx:813
 TStreamerInfo.cxx:814
 TStreamerInfo.cxx:815
 TStreamerInfo.cxx:816
 TStreamerInfo.cxx:817
 TStreamerInfo.cxx:818
 TStreamerInfo.cxx:819
 TStreamerInfo.cxx:820
 TStreamerInfo.cxx:821
 TStreamerInfo.cxx:822
 TStreamerInfo.cxx:823
 TStreamerInfo.cxx:824
 TStreamerInfo.cxx:825
 TStreamerInfo.cxx:826
 TStreamerInfo.cxx:827
 TStreamerInfo.cxx:828
 TStreamerInfo.cxx:829
 TStreamerInfo.cxx:830
 TStreamerInfo.cxx:831
 TStreamerInfo.cxx:832
 TStreamerInfo.cxx:833
 TStreamerInfo.cxx:834
 TStreamerInfo.cxx:835
 TStreamerInfo.cxx:836
 TStreamerInfo.cxx:837
 TStreamerInfo.cxx:838
 TStreamerInfo.cxx:839
 TStreamerInfo.cxx:840
 TStreamerInfo.cxx:841
 TStreamerInfo.cxx:842
 TStreamerInfo.cxx:843
 TStreamerInfo.cxx:844
 TStreamerInfo.cxx:845
 TStreamerInfo.cxx:846
 TStreamerInfo.cxx:847
 TStreamerInfo.cxx:848
 TStreamerInfo.cxx:849
 TStreamerInfo.cxx:850
 TStreamerInfo.cxx:851
 TStreamerInfo.cxx:852
 TStreamerInfo.cxx:853
 TStreamerInfo.cxx:854
 TStreamerInfo.cxx:855
 TStreamerInfo.cxx:856
 TStreamerInfo.cxx:857
 TStreamerInfo.cxx:858
 TStreamerInfo.cxx:859
 TStreamerInfo.cxx:860
 TStreamerInfo.cxx:861
 TStreamerInfo.cxx:862
 TStreamerInfo.cxx:863
 TStreamerInfo.cxx:864
 TStreamerInfo.cxx:865
 TStreamerInfo.cxx:866
 TStreamerInfo.cxx:867
 TStreamerInfo.cxx:868
 TStreamerInfo.cxx:869
 TStreamerInfo.cxx:870
 TStreamerInfo.cxx:871
 TStreamerInfo.cxx:872
 TStreamerInfo.cxx:873
 TStreamerInfo.cxx:874
 TStreamerInfo.cxx:875
 TStreamerInfo.cxx:876
 TStreamerInfo.cxx:877
 TStreamerInfo.cxx:878
 TStreamerInfo.cxx:879
 TStreamerInfo.cxx:880
 TStreamerInfo.cxx:881
 TStreamerInfo.cxx:882
 TStreamerInfo.cxx:883
 TStreamerInfo.cxx:884
 TStreamerInfo.cxx:885
 TStreamerInfo.cxx:886
 TStreamerInfo.cxx:887
 TStreamerInfo.cxx:888
 TStreamerInfo.cxx:889
 TStreamerInfo.cxx:890
 TStreamerInfo.cxx:891
 TStreamerInfo.cxx:892
 TStreamerInfo.cxx:893
 TStreamerInfo.cxx:894
 TStreamerInfo.cxx:895
 TStreamerInfo.cxx:896
 TStreamerInfo.cxx:897
 TStreamerInfo.cxx:898
 TStreamerInfo.cxx:899
 TStreamerInfo.cxx:900
 TStreamerInfo.cxx:901
 TStreamerInfo.cxx:902
 TStreamerInfo.cxx:903
 TStreamerInfo.cxx:904
 TStreamerInfo.cxx:905
 TStreamerInfo.cxx:906
 TStreamerInfo.cxx:907
 TStreamerInfo.cxx:908
 TStreamerInfo.cxx:909
 TStreamerInfo.cxx:910
 TStreamerInfo.cxx:911
 TStreamerInfo.cxx:912
 TStreamerInfo.cxx:913
 TStreamerInfo.cxx:914
 TStreamerInfo.cxx:915
 TStreamerInfo.cxx:916
 TStreamerInfo.cxx:917
 TStreamerInfo.cxx:918
 TStreamerInfo.cxx:919
 TStreamerInfo.cxx:920
 TStreamerInfo.cxx:921
 TStreamerInfo.cxx:922
 TStreamerInfo.cxx:923
 TStreamerInfo.cxx:924
 TStreamerInfo.cxx:925
 TStreamerInfo.cxx:926
 TStreamerInfo.cxx:927
 TStreamerInfo.cxx:928
 TStreamerInfo.cxx:929
 TStreamerInfo.cxx:930
 TStreamerInfo.cxx:931
 TStreamerInfo.cxx:932
 TStreamerInfo.cxx:933
 TStreamerInfo.cxx:934
 TStreamerInfo.cxx:935
 TStreamerInfo.cxx:936
 TStreamerInfo.cxx:937
 TStreamerInfo.cxx:938
 TStreamerInfo.cxx:939
 TStreamerInfo.cxx:940
 TStreamerInfo.cxx:941
 TStreamerInfo.cxx:942
 TStreamerInfo.cxx:943
 TStreamerInfo.cxx:944
 TStreamerInfo.cxx:945
 TStreamerInfo.cxx:946
 TStreamerInfo.cxx:947
 TStreamerInfo.cxx:948
 TStreamerInfo.cxx:949
 TStreamerInfo.cxx:950
 TStreamerInfo.cxx:951
 TStreamerInfo.cxx:952
 TStreamerInfo.cxx:953
 TStreamerInfo.cxx:954
 TStreamerInfo.cxx:955
 TStreamerInfo.cxx:956
 TStreamerInfo.cxx:957
 TStreamerInfo.cxx:958
 TStreamerInfo.cxx:959
 TStreamerInfo.cxx:960
 TStreamerInfo.cxx:961
 TStreamerInfo.cxx:962
 TStreamerInfo.cxx:963
 TStreamerInfo.cxx:964
 TStreamerInfo.cxx:965
 TStreamerInfo.cxx:966
 TStreamerInfo.cxx:967
 TStreamerInfo.cxx:968
 TStreamerInfo.cxx:969
 TStreamerInfo.cxx:970
 TStreamerInfo.cxx:971
 TStreamerInfo.cxx:972
 TStreamerInfo.cxx:973
 TStreamerInfo.cxx:974
 TStreamerInfo.cxx:975
 TStreamerInfo.cxx:976
 TStreamerInfo.cxx:977
 TStreamerInfo.cxx:978
 TStreamerInfo.cxx:979
 TStreamerInfo.cxx:980
 TStreamerInfo.cxx:981
 TStreamerInfo.cxx:982
 TStreamerInfo.cxx:983
 TStreamerInfo.cxx:984
 TStreamerInfo.cxx:985
 TStreamerInfo.cxx:986
 TStreamerInfo.cxx:987
 TStreamerInfo.cxx:988
 TStreamerInfo.cxx:989
 TStreamerInfo.cxx:990
 TStreamerInfo.cxx:991
 TStreamerInfo.cxx:992
 TStreamerInfo.cxx:993
 TStreamerInfo.cxx:994
 TStreamerInfo.cxx:995
 TStreamerInfo.cxx:996
 TStreamerInfo.cxx:997
 TStreamerInfo.cxx:998
 TStreamerInfo.cxx:999
 TStreamerInfo.cxx:1000
 TStreamerInfo.cxx:1001
 TStreamerInfo.cxx:1002
 TStreamerInfo.cxx:1003
 TStreamerInfo.cxx:1004
 TStreamerInfo.cxx:1005
 TStreamerInfo.cxx:1006
 TStreamerInfo.cxx:1007
 TStreamerInfo.cxx:1008
 TStreamerInfo.cxx:1009
 TStreamerInfo.cxx:1010
 TStreamerInfo.cxx:1011
 TStreamerInfo.cxx:1012
 TStreamerInfo.cxx:1013
 TStreamerInfo.cxx:1014
 TStreamerInfo.cxx:1015
 TStreamerInfo.cxx:1016
 TStreamerInfo.cxx:1017
 TStreamerInfo.cxx:1018
 TStreamerInfo.cxx:1019
 TStreamerInfo.cxx:1020
 TStreamerInfo.cxx:1021
 TStreamerInfo.cxx:1022
 TStreamerInfo.cxx:1023
 TStreamerInfo.cxx:1024
 TStreamerInfo.cxx:1025
 TStreamerInfo.cxx:1026
 TStreamerInfo.cxx:1027
 TStreamerInfo.cxx:1028
 TStreamerInfo.cxx:1029
 TStreamerInfo.cxx:1030
 TStreamerInfo.cxx:1031
 TStreamerInfo.cxx:1032
 TStreamerInfo.cxx:1033
 TStreamerInfo.cxx:1034
 TStreamerInfo.cxx:1035
 TStreamerInfo.cxx:1036
 TStreamerInfo.cxx:1037
 TStreamerInfo.cxx:1038
 TStreamerInfo.cxx:1039
 TStreamerInfo.cxx:1040
 TStreamerInfo.cxx:1041
 TStreamerInfo.cxx:1042
 TStreamerInfo.cxx:1043
 TStreamerInfo.cxx:1044
 TStreamerInfo.cxx:1045
 TStreamerInfo.cxx:1046
 TStreamerInfo.cxx:1047
 TStreamerInfo.cxx:1048
 TStreamerInfo.cxx:1049
 TStreamerInfo.cxx:1050
 TStreamerInfo.cxx:1051
 TStreamerInfo.cxx:1052
 TStreamerInfo.cxx:1053
 TStreamerInfo.cxx:1054
 TStreamerInfo.cxx:1055
 TStreamerInfo.cxx:1056
 TStreamerInfo.cxx:1057
 TStreamerInfo.cxx:1058
 TStreamerInfo.cxx:1059
 TStreamerInfo.cxx:1060
 TStreamerInfo.cxx:1061
 TStreamerInfo.cxx:1062
 TStreamerInfo.cxx:1063
 TStreamerInfo.cxx:1064
 TStreamerInfo.cxx:1065
 TStreamerInfo.cxx:1066
 TStreamerInfo.cxx:1067
 TStreamerInfo.cxx:1068
 TStreamerInfo.cxx:1069
 TStreamerInfo.cxx:1070
 TStreamerInfo.cxx:1071
 TStreamerInfo.cxx:1072
 TStreamerInfo.cxx:1073
 TStreamerInfo.cxx:1074
 TStreamerInfo.cxx:1075
 TStreamerInfo.cxx:1076
 TStreamerInfo.cxx:1077
 TStreamerInfo.cxx:1078
 TStreamerInfo.cxx:1079
 TStreamerInfo.cxx:1080
 TStreamerInfo.cxx:1081
 TStreamerInfo.cxx:1082
 TStreamerInfo.cxx:1083
 TStreamerInfo.cxx:1084
 TStreamerInfo.cxx:1085
 TStreamerInfo.cxx:1086
 TStreamerInfo.cxx:1087
 TStreamerInfo.cxx:1088
 TStreamerInfo.cxx:1089
 TStreamerInfo.cxx:1090
 TStreamerInfo.cxx:1091
 TStreamerInfo.cxx:1092
 TStreamerInfo.cxx:1093
 TStreamerInfo.cxx:1094
 TStreamerInfo.cxx:1095
 TStreamerInfo.cxx:1096
 TStreamerInfo.cxx:1097
 TStreamerInfo.cxx:1098
 TStreamerInfo.cxx:1099
 TStreamerInfo.cxx:1100
 TStreamerInfo.cxx:1101
 TStreamerInfo.cxx:1102
 TStreamerInfo.cxx:1103
 TStreamerInfo.cxx:1104
 TStreamerInfo.cxx:1105
 TStreamerInfo.cxx:1106
 TStreamerInfo.cxx:1107
 TStreamerInfo.cxx:1108
 TStreamerInfo.cxx:1109
 TStreamerInfo.cxx:1110
 TStreamerInfo.cxx:1111
 TStreamerInfo.cxx:1112
 TStreamerInfo.cxx:1113
 TStreamerInfo.cxx:1114
 TStreamerInfo.cxx:1115
 TStreamerInfo.cxx:1116
 TStreamerInfo.cxx:1117
 TStreamerInfo.cxx:1118
 TStreamerInfo.cxx:1119
 TStreamerInfo.cxx:1120
 TStreamerInfo.cxx:1121
 TStreamerInfo.cxx:1122
 TStreamerInfo.cxx:1123
 TStreamerInfo.cxx:1124
 TStreamerInfo.cxx:1125
 TStreamerInfo.cxx:1126
 TStreamerInfo.cxx:1127
 TStreamerInfo.cxx:1128
 TStreamerInfo.cxx:1129
 TStreamerInfo.cxx:1130
 TStreamerInfo.cxx:1131
 TStreamerInfo.cxx:1132
 TStreamerInfo.cxx:1133
 TStreamerInfo.cxx:1134
 TStreamerInfo.cxx:1135
 TStreamerInfo.cxx:1136
 TStreamerInfo.cxx:1137
 TStreamerInfo.cxx:1138
 TStreamerInfo.cxx:1139
 TStreamerInfo.cxx:1140
 TStreamerInfo.cxx:1141
 TStreamerInfo.cxx:1142
 TStreamerInfo.cxx:1143
 TStreamerInfo.cxx:1144
 TStreamerInfo.cxx:1145
 TStreamerInfo.cxx:1146
 TStreamerInfo.cxx:1147
 TStreamerInfo.cxx:1148
 TStreamerInfo.cxx:1149
 TStreamerInfo.cxx:1150
 TStreamerInfo.cxx:1151
 TStreamerInfo.cxx:1152
 TStreamerInfo.cxx:1153
 TStreamerInfo.cxx:1154
 TStreamerInfo.cxx:1155
 TStreamerInfo.cxx:1156
 TStreamerInfo.cxx:1157
 TStreamerInfo.cxx:1158
 TStreamerInfo.cxx:1159
 TStreamerInfo.cxx:1160
 TStreamerInfo.cxx:1161
 TStreamerInfo.cxx:1162
 TStreamerInfo.cxx:1163
 TStreamerInfo.cxx:1164
 TStreamerInfo.cxx:1165
 TStreamerInfo.cxx:1166
 TStreamerInfo.cxx:1167
 TStreamerInfo.cxx:1168
 TStreamerInfo.cxx:1169
 TStreamerInfo.cxx:1170
 TStreamerInfo.cxx:1171
 TStreamerInfo.cxx:1172
 TStreamerInfo.cxx:1173
 TStreamerInfo.cxx:1174
 TStreamerInfo.cxx:1175
 TStreamerInfo.cxx:1176
 TStreamerInfo.cxx:1177
 TStreamerInfo.cxx:1178
 TStreamerInfo.cxx:1179
 TStreamerInfo.cxx:1180
 TStreamerInfo.cxx:1181
 TStreamerInfo.cxx:1182
 TStreamerInfo.cxx:1183
 TStreamerInfo.cxx:1184
 TStreamerInfo.cxx:1185
 TStreamerInfo.cxx:1186
 TStreamerInfo.cxx:1187
 TStreamerInfo.cxx:1188
 TStreamerInfo.cxx:1189
 TStreamerInfo.cxx:1190
 TStreamerInfo.cxx:1191
 TStreamerInfo.cxx:1192
 TStreamerInfo.cxx:1193
 TStreamerInfo.cxx:1194
 TStreamerInfo.cxx:1195
 TStreamerInfo.cxx:1196
 TStreamerInfo.cxx:1197
 TStreamerInfo.cxx:1198
 TStreamerInfo.cxx:1199
 TStreamerInfo.cxx:1200
 TStreamerInfo.cxx:1201
 TStreamerInfo.cxx:1202
 TStreamerInfo.cxx:1203
 TStreamerInfo.cxx:1204
 TStreamerInfo.cxx:1205
 TStreamerInfo.cxx:1206
 TStreamerInfo.cxx:1207
 TStreamerInfo.cxx:1208
 TStreamerInfo.cxx:1209
 TStreamerInfo.cxx:1210
 TStreamerInfo.cxx:1211
 TStreamerInfo.cxx:1212
 TStreamerInfo.cxx:1213
 TStreamerInfo.cxx:1214
 TStreamerInfo.cxx:1215
 TStreamerInfo.cxx:1216
 TStreamerInfo.cxx:1217
 TStreamerInfo.cxx:1218
 TStreamerInfo.cxx:1219
 TStreamerInfo.cxx:1220
 TStreamerInfo.cxx:1221
 TStreamerInfo.cxx:1222
 TStreamerInfo.cxx:1223
 TStreamerInfo.cxx:1224
 TStreamerInfo.cxx:1225
 TStreamerInfo.cxx:1226
 TStreamerInfo.cxx:1227
 TStreamerInfo.cxx:1228
 TStreamerInfo.cxx:1229
 TStreamerInfo.cxx:1230
 TStreamerInfo.cxx:1231
 TStreamerInfo.cxx:1232
 TStreamerInfo.cxx:1233
 TStreamerInfo.cxx:1234
 TStreamerInfo.cxx:1235
 TStreamerInfo.cxx:1236
 TStreamerInfo.cxx:1237
 TStreamerInfo.cxx:1238
 TStreamerInfo.cxx:1239
 TStreamerInfo.cxx:1240
 TStreamerInfo.cxx:1241
 TStreamerInfo.cxx:1242
 TStreamerInfo.cxx:1243
 TStreamerInfo.cxx:1244
 TStreamerInfo.cxx:1245
 TStreamerInfo.cxx:1246
 TStreamerInfo.cxx:1247
 TStreamerInfo.cxx:1248
 TStreamerInfo.cxx:1249
 TStreamerInfo.cxx:1250
 TStreamerInfo.cxx:1251
 TStreamerInfo.cxx:1252
 TStreamerInfo.cxx:1253
 TStreamerInfo.cxx:1254
 TStreamerInfo.cxx:1255
 TStreamerInfo.cxx:1256
 TStreamerInfo.cxx:1257
 TStreamerInfo.cxx:1258
 TStreamerInfo.cxx:1259
 TStreamerInfo.cxx:1260
 TStreamerInfo.cxx:1261
 TStreamerInfo.cxx:1262
 TStreamerInfo.cxx:1263
 TStreamerInfo.cxx:1264
 TStreamerInfo.cxx:1265
 TStreamerInfo.cxx:1266
 TStreamerInfo.cxx:1267
 TStreamerInfo.cxx:1268
 TStreamerInfo.cxx:1269
 TStreamerInfo.cxx:1270
 TStreamerInfo.cxx:1271
 TStreamerInfo.cxx:1272
 TStreamerInfo.cxx:1273
 TStreamerInfo.cxx:1274
 TStreamerInfo.cxx:1275
 TStreamerInfo.cxx:1276
 TStreamerInfo.cxx:1277
 TStreamerInfo.cxx:1278
 TStreamerInfo.cxx:1279
 TStreamerInfo.cxx:1280
 TStreamerInfo.cxx:1281
 TStreamerInfo.cxx:1282
 TStreamerInfo.cxx:1283
 TStreamerInfo.cxx:1284
 TStreamerInfo.cxx:1285
 TStreamerInfo.cxx:1286
 TStreamerInfo.cxx:1287
 TStreamerInfo.cxx:1288
 TStreamerInfo.cxx:1289
 TStreamerInfo.cxx:1290
 TStreamerInfo.cxx:1291
 TStreamerInfo.cxx:1292
 TStreamerInfo.cxx:1293
 TStreamerInfo.cxx:1294
 TStreamerInfo.cxx:1295
 TStreamerInfo.cxx:1296
 TStreamerInfo.cxx:1297
 TStreamerInfo.cxx:1298
 TStreamerInfo.cxx:1299
 TStreamerInfo.cxx:1300
 TStreamerInfo.cxx:1301
 TStreamerInfo.cxx:1302
 TStreamerInfo.cxx:1303
 TStreamerInfo.cxx:1304
 TStreamerInfo.cxx:1305
 TStreamerInfo.cxx:1306
 TStreamerInfo.cxx:1307
 TStreamerInfo.cxx:1308
 TStreamerInfo.cxx:1309
 TStreamerInfo.cxx:1310
 TStreamerInfo.cxx:1311
 TStreamerInfo.cxx:1312
 TStreamerInfo.cxx:1313
 TStreamerInfo.cxx:1314
 TStreamerInfo.cxx:1315
 TStreamerInfo.cxx:1316
 TStreamerInfo.cxx:1317
 TStreamerInfo.cxx:1318
 TStreamerInfo.cxx:1319
 TStreamerInfo.cxx:1320
 TStreamerInfo.cxx:1321
 TStreamerInfo.cxx:1322
 TStreamerInfo.cxx:1323
 TStreamerInfo.cxx:1324
 TStreamerInfo.cxx:1325
 TStreamerInfo.cxx:1326
 TStreamerInfo.cxx:1327
 TStreamerInfo.cxx:1328
 TStreamerInfo.cxx:1329
 TStreamerInfo.cxx:1330
 TStreamerInfo.cxx:1331
 TStreamerInfo.cxx:1332
 TStreamerInfo.cxx:1333
 TStreamerInfo.cxx:1334
 TStreamerInfo.cxx:1335
 TStreamerInfo.cxx:1336
 TStreamerInfo.cxx:1337
 TStreamerInfo.cxx:1338
 TStreamerInfo.cxx:1339
 TStreamerInfo.cxx:1340
 TStreamerInfo.cxx:1341
 TStreamerInfo.cxx:1342
 TStreamerInfo.cxx:1343
 TStreamerInfo.cxx:1344
 TStreamerInfo.cxx:1345
 TStreamerInfo.cxx:1346
 TStreamerInfo.cxx:1347
 TStreamerInfo.cxx:1348
 TStreamerInfo.cxx:1349
 TStreamerInfo.cxx:1350
 TStreamerInfo.cxx:1351
 TStreamerInfo.cxx:1352
 TStreamerInfo.cxx:1353
 TStreamerInfo.cxx:1354
 TStreamerInfo.cxx:1355
 TStreamerInfo.cxx:1356
 TStreamerInfo.cxx:1357
 TStreamerInfo.cxx:1358
 TStreamerInfo.cxx:1359
 TStreamerInfo.cxx:1360
 TStreamerInfo.cxx:1361
 TStreamerInfo.cxx:1362
 TStreamerInfo.cxx:1363
 TStreamerInfo.cxx:1364
 TStreamerInfo.cxx:1365
 TStreamerInfo.cxx:1366
 TStreamerInfo.cxx:1367
 TStreamerInfo.cxx:1368
 TStreamerInfo.cxx:1369
 TStreamerInfo.cxx:1370
 TStreamerInfo.cxx:1371
 TStreamerInfo.cxx:1372
 TStreamerInfo.cxx:1373
 TStreamerInfo.cxx:1374
 TStreamerInfo.cxx:1375
 TStreamerInfo.cxx:1376
 TStreamerInfo.cxx:1377
 TStreamerInfo.cxx:1378
 TStreamerInfo.cxx:1379
 TStreamerInfo.cxx:1380
 TStreamerInfo.cxx:1381
 TStreamerInfo.cxx:1382
 TStreamerInfo.cxx:1383
 TStreamerInfo.cxx:1384
 TStreamerInfo.cxx:1385
 TStreamerInfo.cxx:1386
 TStreamerInfo.cxx:1387
 TStreamerInfo.cxx:1388
 TStreamerInfo.cxx:1389
 TStreamerInfo.cxx:1390
 TStreamerInfo.cxx:1391
 TStreamerInfo.cxx:1392
 TStreamerInfo.cxx:1393
 TStreamerInfo.cxx:1394
 TStreamerInfo.cxx:1395
 TStreamerInfo.cxx:1396
 TStreamerInfo.cxx:1397
 TStreamerInfo.cxx:1398
 TStreamerInfo.cxx:1399
 TStreamerInfo.cxx:1400
 TStreamerInfo.cxx:1401
 TStreamerInfo.cxx:1402
 TStreamerInfo.cxx:1403
 TStreamerInfo.cxx:1404
 TStreamerInfo.cxx:1405
 TStreamerInfo.cxx:1406
 TStreamerInfo.cxx:1407
 TStreamerInfo.cxx:1408
 TStreamerInfo.cxx:1409
 TStreamerInfo.cxx:1410
 TStreamerInfo.cxx:1411
 TStreamerInfo.cxx:1412
 TStreamerInfo.cxx:1413
 TStreamerInfo.cxx:1414
 TStreamerInfo.cxx:1415
 TStreamerInfo.cxx:1416
 TStreamerInfo.cxx:1417
 TStreamerInfo.cxx:1418
 TStreamerInfo.cxx:1419
 TStreamerInfo.cxx:1420
 TStreamerInfo.cxx:1421
 TStreamerInfo.cxx:1422
 TStreamerInfo.cxx:1423
 TStreamerInfo.cxx:1424
 TStreamerInfo.cxx:1425
 TStreamerInfo.cxx:1426
 TStreamerInfo.cxx:1427
 TStreamerInfo.cxx:1428
 TStreamerInfo.cxx:1429
 TStreamerInfo.cxx:1430
 TStreamerInfo.cxx:1431
 TStreamerInfo.cxx:1432
 TStreamerInfo.cxx:1433
 TStreamerInfo.cxx:1434
 TStreamerInfo.cxx:1435
 TStreamerInfo.cxx:1436
 TStreamerInfo.cxx:1437
 TStreamerInfo.cxx:1438
 TStreamerInfo.cxx:1439
 TStreamerInfo.cxx:1440
 TStreamerInfo.cxx:1441
 TStreamerInfo.cxx:1442
 TStreamerInfo.cxx:1443
 TStreamerInfo.cxx:1444
 TStreamerInfo.cxx:1445
 TStreamerInfo.cxx:1446
 TStreamerInfo.cxx:1447
 TStreamerInfo.cxx:1448
 TStreamerInfo.cxx:1449
 TStreamerInfo.cxx:1450
 TStreamerInfo.cxx:1451
 TStreamerInfo.cxx:1452
 TStreamerInfo.cxx:1453
 TStreamerInfo.cxx:1454
 TStreamerInfo.cxx:1455
 TStreamerInfo.cxx:1456
 TStreamerInfo.cxx:1457
 TStreamerInfo.cxx:1458
 TStreamerInfo.cxx:1459
 TStreamerInfo.cxx:1460
 TStreamerInfo.cxx:1461
 TStreamerInfo.cxx:1462
 TStreamerInfo.cxx:1463
 TStreamerInfo.cxx:1464
 TStreamerInfo.cxx:1465
 TStreamerInfo.cxx:1466
 TStreamerInfo.cxx:1467
 TStreamerInfo.cxx:1468
 TStreamerInfo.cxx:1469
 TStreamerInfo.cxx:1470
 TStreamerInfo.cxx:1471
 TStreamerInfo.cxx:1472
 TStreamerInfo.cxx:1473
 TStreamerInfo.cxx:1474
 TStreamerInfo.cxx:1475
 TStreamerInfo.cxx:1476
 TStreamerInfo.cxx:1477
 TStreamerInfo.cxx:1478
 TStreamerInfo.cxx:1479
 TStreamerInfo.cxx:1480
 TStreamerInfo.cxx:1481
 TStreamerInfo.cxx:1482
 TStreamerInfo.cxx:1483
 TStreamerInfo.cxx:1484
 TStreamerInfo.cxx:1485
 TStreamerInfo.cxx:1486
 TStreamerInfo.cxx:1487
 TStreamerInfo.cxx:1488
 TStreamerInfo.cxx:1489
 TStreamerInfo.cxx:1490
 TStreamerInfo.cxx:1491
 TStreamerInfo.cxx:1492
 TStreamerInfo.cxx:1493
 TStreamerInfo.cxx:1494
 TStreamerInfo.cxx:1495
 TStreamerInfo.cxx:1496
 TStreamerInfo.cxx:1497
 TStreamerInfo.cxx:1498
 TStreamerInfo.cxx:1499
 TStreamerInfo.cxx:1500
 TStreamerInfo.cxx:1501
 TStreamerInfo.cxx:1502
 TStreamerInfo.cxx:1503
 TStreamerInfo.cxx:1504
 TStreamerInfo.cxx:1505
 TStreamerInfo.cxx:1506
 TStreamerInfo.cxx:1507
 TStreamerInfo.cxx:1508
 TStreamerInfo.cxx:1509
 TStreamerInfo.cxx:1510
 TStreamerInfo.cxx:1511
 TStreamerInfo.cxx:1512
 TStreamerInfo.cxx:1513
 TStreamerInfo.cxx:1514
 TStreamerInfo.cxx:1515
 TStreamerInfo.cxx:1516
 TStreamerInfo.cxx:1517
 TStreamerInfo.cxx:1518
 TStreamerInfo.cxx:1519
 TStreamerInfo.cxx:1520
 TStreamerInfo.cxx:1521
 TStreamerInfo.cxx:1522
 TStreamerInfo.cxx:1523
 TStreamerInfo.cxx:1524
 TStreamerInfo.cxx:1525
 TStreamerInfo.cxx:1526
 TStreamerInfo.cxx:1527
 TStreamerInfo.cxx:1528
 TStreamerInfo.cxx:1529
 TStreamerInfo.cxx:1530
 TStreamerInfo.cxx:1531
 TStreamerInfo.cxx:1532
 TStreamerInfo.cxx:1533
 TStreamerInfo.cxx:1534
 TStreamerInfo.cxx:1535
 TStreamerInfo.cxx:1536
 TStreamerInfo.cxx:1537
 TStreamerInfo.cxx:1538
 TStreamerInfo.cxx:1539
 TStreamerInfo.cxx:1540
 TStreamerInfo.cxx:1541
 TStreamerInfo.cxx:1542
 TStreamerInfo.cxx:1543
 TStreamerInfo.cxx:1544
 TStreamerInfo.cxx:1545
 TStreamerInfo.cxx:1546
 TStreamerInfo.cxx:1547
 TStreamerInfo.cxx:1548
 TStreamerInfo.cxx:1549
 TStreamerInfo.cxx:1550
 TStreamerInfo.cxx:1551
 TStreamerInfo.cxx:1552
 TStreamerInfo.cxx:1553
 TStreamerInfo.cxx:1554
 TStreamerInfo.cxx:1555
 TStreamerInfo.cxx:1556
 TStreamerInfo.cxx:1557
 TStreamerInfo.cxx:1558
 TStreamerInfo.cxx:1559
 TStreamerInfo.cxx:1560
 TStreamerInfo.cxx:1561
 TStreamerInfo.cxx:1562
 TStreamerInfo.cxx:1563
 TStreamerInfo.cxx:1564
 TStreamerInfo.cxx:1565
 TStreamerInfo.cxx:1566
 TStreamerInfo.cxx:1567
 TStreamerInfo.cxx:1568
 TStreamerInfo.cxx:1569
 TStreamerInfo.cxx:1570
 TStreamerInfo.cxx:1571
 TStreamerInfo.cxx:1572
 TStreamerInfo.cxx:1573
 TStreamerInfo.cxx:1574
 TStreamerInfo.cxx:1575
 TStreamerInfo.cxx:1576
 TStreamerInfo.cxx:1577
 TStreamerInfo.cxx:1578
 TStreamerInfo.cxx:1579
 TStreamerInfo.cxx:1580
 TStreamerInfo.cxx:1581
 TStreamerInfo.cxx:1582
 TStreamerInfo.cxx:1583
 TStreamerInfo.cxx:1584
 TStreamerInfo.cxx:1585
 TStreamerInfo.cxx:1586
 TStreamerInfo.cxx:1587
 TStreamerInfo.cxx:1588
 TStreamerInfo.cxx:1589
 TStreamerInfo.cxx:1590
 TStreamerInfo.cxx:1591
 TStreamerInfo.cxx:1592
 TStreamerInfo.cxx:1593
 TStreamerInfo.cxx:1594
 TStreamerInfo.cxx:1595
 TStreamerInfo.cxx:1596
 TStreamerInfo.cxx:1597
 TStreamerInfo.cxx:1598
 TStreamerInfo.cxx:1599
 TStreamerInfo.cxx:1600
 TStreamerInfo.cxx:1601
 TStreamerInfo.cxx:1602
 TStreamerInfo.cxx:1603
 TStreamerInfo.cxx:1604
 TStreamerInfo.cxx:1605
 TStreamerInfo.cxx:1606
 TStreamerInfo.cxx:1607
 TStreamerInfo.cxx:1608
 TStreamerInfo.cxx:1609
 TStreamerInfo.cxx:1610
 TStreamerInfo.cxx:1611
 TStreamerInfo.cxx:1612
 TStreamerInfo.cxx:1613
 TStreamerInfo.cxx:1614
 TStreamerInfo.cxx:1615
 TStreamerInfo.cxx:1616
 TStreamerInfo.cxx:1617
 TStreamerInfo.cxx:1618
 TStreamerInfo.cxx:1619
 TStreamerInfo.cxx:1620
 TStreamerInfo.cxx:1621
 TStreamerInfo.cxx:1622
 TStreamerInfo.cxx:1623
 TStreamerInfo.cxx:1624
 TStreamerInfo.cxx:1625
 TStreamerInfo.cxx:1626
 TStreamerInfo.cxx:1627
 TStreamerInfo.cxx:1628
 TStreamerInfo.cxx:1629
 TStreamerInfo.cxx:1630
 TStreamerInfo.cxx:1631
 TStreamerInfo.cxx:1632
 TStreamerInfo.cxx:1633
 TStreamerInfo.cxx:1634
 TStreamerInfo.cxx:1635
 TStreamerInfo.cxx:1636
 TStreamerInfo.cxx:1637
 TStreamerInfo.cxx:1638
 TStreamerInfo.cxx:1639
 TStreamerInfo.cxx:1640
 TStreamerInfo.cxx:1641
 TStreamerInfo.cxx:1642
 TStreamerInfo.cxx:1643
 TStreamerInfo.cxx:1644
 TStreamerInfo.cxx:1645
 TStreamerInfo.cxx:1646
 TStreamerInfo.cxx:1647
 TStreamerInfo.cxx:1648
 TStreamerInfo.cxx:1649
 TStreamerInfo.cxx:1650
 TStreamerInfo.cxx:1651
 TStreamerInfo.cxx:1652
 TStreamerInfo.cxx:1653
 TStreamerInfo.cxx:1654
 TStreamerInfo.cxx:1655
 TStreamerInfo.cxx:1656
 TStreamerInfo.cxx:1657
 TStreamerInfo.cxx:1658
 TStreamerInfo.cxx:1659
 TStreamerInfo.cxx:1660
 TStreamerInfo.cxx:1661
 TStreamerInfo.cxx:1662
 TStreamerInfo.cxx:1663
 TStreamerInfo.cxx:1664
 TStreamerInfo.cxx:1665
 TStreamerInfo.cxx:1666
 TStreamerInfo.cxx:1667
 TStreamerInfo.cxx:1668
 TStreamerInfo.cxx:1669
 TStreamerInfo.cxx:1670
 TStreamerInfo.cxx:1671
 TStreamerInfo.cxx:1672
 TStreamerInfo.cxx:1673
 TStreamerInfo.cxx:1674
 TStreamerInfo.cxx:1675
 TStreamerInfo.cxx:1676
 TStreamerInfo.cxx:1677
 TStreamerInfo.cxx:1678
 TStreamerInfo.cxx:1679
 TStreamerInfo.cxx:1680
 TStreamerInfo.cxx:1681
 TStreamerInfo.cxx:1682
 TStreamerInfo.cxx:1683
 TStreamerInfo.cxx:1684
 TStreamerInfo.cxx:1685
 TStreamerInfo.cxx:1686
 TStreamerInfo.cxx:1687
 TStreamerInfo.cxx:1688
 TStreamerInfo.cxx:1689
 TStreamerInfo.cxx:1690
 TStreamerInfo.cxx:1691
 TStreamerInfo.cxx:1692
 TStreamerInfo.cxx:1693
 TStreamerInfo.cxx:1694
 TStreamerInfo.cxx:1695
 TStreamerInfo.cxx:1696
 TStreamerInfo.cxx:1697
 TStreamerInfo.cxx:1698
 TStreamerInfo.cxx:1699
 TStreamerInfo.cxx:1700
 TStreamerInfo.cxx:1701
 TStreamerInfo.cxx:1702
 TStreamerInfo.cxx:1703
 TStreamerInfo.cxx:1704
 TStreamerInfo.cxx:1705
 TStreamerInfo.cxx:1706
 TStreamerInfo.cxx:1707
 TStreamerInfo.cxx:1708
 TStreamerInfo.cxx:1709
 TStreamerInfo.cxx:1710
 TStreamerInfo.cxx:1711
 TStreamerInfo.cxx:1712
 TStreamerInfo.cxx:1713
 TStreamerInfo.cxx:1714
 TStreamerInfo.cxx:1715
 TStreamerInfo.cxx:1716
 TStreamerInfo.cxx:1717
 TStreamerInfo.cxx:1718
 TStreamerInfo.cxx:1719
 TStreamerInfo.cxx:1720
 TStreamerInfo.cxx:1721
 TStreamerInfo.cxx:1722
 TStreamerInfo.cxx:1723
 TStreamerInfo.cxx:1724
 TStreamerInfo.cxx:1725
 TStreamerInfo.cxx:1726
 TStreamerInfo.cxx:1727
 TStreamerInfo.cxx:1728
 TStreamerInfo.cxx:1729
 TStreamerInfo.cxx:1730
 TStreamerInfo.cxx:1731
 TStreamerInfo.cxx:1732
 TStreamerInfo.cxx:1733
 TStreamerInfo.cxx:1734
 TStreamerInfo.cxx:1735
 TStreamerInfo.cxx:1736
 TStreamerInfo.cxx:1737
 TStreamerInfo.cxx:1738
 TStreamerInfo.cxx:1739
 TStreamerInfo.cxx:1740
 TStreamerInfo.cxx:1741
 TStreamerInfo.cxx:1742
 TStreamerInfo.cxx:1743
 TStreamerInfo.cxx:1744
 TStreamerInfo.cxx:1745
 TStreamerInfo.cxx:1746
 TStreamerInfo.cxx:1747
 TStreamerInfo.cxx:1748
 TStreamerInfo.cxx:1749
 TStreamerInfo.cxx:1750
 TStreamerInfo.cxx:1751
 TStreamerInfo.cxx:1752
 TStreamerInfo.cxx:1753
 TStreamerInfo.cxx:1754
 TStreamerInfo.cxx:1755
 TStreamerInfo.cxx:1756
 TStreamerInfo.cxx:1757
 TStreamerInfo.cxx:1758
 TStreamerInfo.cxx:1759
 TStreamerInfo.cxx:1760
 TStreamerInfo.cxx:1761
 TStreamerInfo.cxx:1762
 TStreamerInfo.cxx:1763
 TStreamerInfo.cxx:1764
 TStreamerInfo.cxx:1765
 TStreamerInfo.cxx:1766
 TStreamerInfo.cxx:1767
 TStreamerInfo.cxx:1768
 TStreamerInfo.cxx:1769
 TStreamerInfo.cxx:1770
 TStreamerInfo.cxx:1771
 TStreamerInfo.cxx:1772
 TStreamerInfo.cxx:1773
 TStreamerInfo.cxx:1774
 TStreamerInfo.cxx:1775
 TStreamerInfo.cxx:1776
 TStreamerInfo.cxx:1777
 TStreamerInfo.cxx:1778
 TStreamerInfo.cxx:1779
 TStreamerInfo.cxx:1780
 TStreamerInfo.cxx:1781
 TStreamerInfo.cxx:1782
 TStreamerInfo.cxx:1783
 TStreamerInfo.cxx:1784
 TStreamerInfo.cxx:1785
 TStreamerInfo.cxx:1786
 TStreamerInfo.cxx:1787
 TStreamerInfo.cxx:1788
 TStreamerInfo.cxx:1789
 TStreamerInfo.cxx:1790
 TStreamerInfo.cxx:1791
 TStreamerInfo.cxx:1792
 TStreamerInfo.cxx:1793
 TStreamerInfo.cxx:1794
 TStreamerInfo.cxx:1795
 TStreamerInfo.cxx:1796
 TStreamerInfo.cxx:1797
 TStreamerInfo.cxx:1798
 TStreamerInfo.cxx:1799
 TStreamerInfo.cxx:1800
 TStreamerInfo.cxx:1801
 TStreamerInfo.cxx:1802
 TStreamerInfo.cxx:1803
 TStreamerInfo.cxx:1804
 TStreamerInfo.cxx:1805
 TStreamerInfo.cxx:1806
 TStreamerInfo.cxx:1807
 TStreamerInfo.cxx:1808
 TStreamerInfo.cxx:1809
 TStreamerInfo.cxx:1810
 TStreamerInfo.cxx:1811
 TStreamerInfo.cxx:1812
 TStreamerInfo.cxx:1813
 TStreamerInfo.cxx:1814
 TStreamerInfo.cxx:1815
 TStreamerInfo.cxx:1816
 TStreamerInfo.cxx:1817
 TStreamerInfo.cxx:1818
 TStreamerInfo.cxx:1819
 TStreamerInfo.cxx:1820
 TStreamerInfo.cxx:1821
 TStreamerInfo.cxx:1822
 TStreamerInfo.cxx:1823
 TStreamerInfo.cxx:1824
 TStreamerInfo.cxx:1825
 TStreamerInfo.cxx:1826
 TStreamerInfo.cxx:1827
 TStreamerInfo.cxx:1828
 TStreamerInfo.cxx:1829
 TStreamerInfo.cxx:1830
 TStreamerInfo.cxx:1831
 TStreamerInfo.cxx:1832
 TStreamerInfo.cxx:1833
 TStreamerInfo.cxx:1834
 TStreamerInfo.cxx:1835
 TStreamerInfo.cxx:1836
 TStreamerInfo.cxx:1837
 TStreamerInfo.cxx:1838
 TStreamerInfo.cxx:1839
 TStreamerInfo.cxx:1840
 TStreamerInfo.cxx:1841
 TStreamerInfo.cxx:1842
 TStreamerInfo.cxx:1843
 TStreamerInfo.cxx:1844
 TStreamerInfo.cxx:1845
 TStreamerInfo.cxx:1846
 TStreamerInfo.cxx:1847
 TStreamerInfo.cxx:1848
 TStreamerInfo.cxx:1849
 TStreamerInfo.cxx:1850
 TStreamerInfo.cxx:1851
 TStreamerInfo.cxx:1852
 TStreamerInfo.cxx:1853
 TStreamerInfo.cxx:1854
 TStreamerInfo.cxx:1855
 TStreamerInfo.cxx:1856
 TStreamerInfo.cxx:1857
 TStreamerInfo.cxx:1858
 TStreamerInfo.cxx:1859
 TStreamerInfo.cxx:1860
 TStreamerInfo.cxx:1861
 TStreamerInfo.cxx:1862
 TStreamerInfo.cxx:1863
 TStreamerInfo.cxx:1864
 TStreamerInfo.cxx:1865
 TStreamerInfo.cxx:1866
 TStreamerInfo.cxx:1867
 TStreamerInfo.cxx:1868
 TStreamerInfo.cxx:1869
 TStreamerInfo.cxx:1870
 TStreamerInfo.cxx:1871
 TStreamerInfo.cxx:1872
 TStreamerInfo.cxx:1873
 TStreamerInfo.cxx:1874
 TStreamerInfo.cxx:1875
 TStreamerInfo.cxx:1876
 TStreamerInfo.cxx:1877
 TStreamerInfo.cxx:1878
 TStreamerInfo.cxx:1879
 TStreamerInfo.cxx:1880
 TStreamerInfo.cxx:1881
 TStreamerInfo.cxx:1882
 TStreamerInfo.cxx:1883
 TStreamerInfo.cxx:1884
 TStreamerInfo.cxx:1885
 TStreamerInfo.cxx:1886
 TStreamerInfo.cxx:1887
 TStreamerInfo.cxx:1888
 TStreamerInfo.cxx:1889
 TStreamerInfo.cxx:1890
 TStreamerInfo.cxx:1891
 TStreamerInfo.cxx:1892
 TStreamerInfo.cxx:1893
 TStreamerInfo.cxx:1894
 TStreamerInfo.cxx:1895
 TStreamerInfo.cxx:1896
 TStreamerInfo.cxx:1897
 TStreamerInfo.cxx:1898
 TStreamerInfo.cxx:1899
 TStreamerInfo.cxx:1900
 TStreamerInfo.cxx:1901
 TStreamerInfo.cxx:1902
 TStreamerInfo.cxx:1903
 TStreamerInfo.cxx:1904
 TStreamerInfo.cxx:1905
 TStreamerInfo.cxx:1906
 TStreamerInfo.cxx:1907
 TStreamerInfo.cxx:1908
 TStreamerInfo.cxx:1909
 TStreamerInfo.cxx:1910
 TStreamerInfo.cxx:1911
 TStreamerInfo.cxx:1912
 TStreamerInfo.cxx:1913
 TStreamerInfo.cxx:1914
 TStreamerInfo.cxx:1915
 TStreamerInfo.cxx:1916
 TStreamerInfo.cxx:1917
 TStreamerInfo.cxx:1918
 TStreamerInfo.cxx:1919
 TStreamerInfo.cxx:1920
 TStreamerInfo.cxx:1921
 TStreamerInfo.cxx:1922
 TStreamerInfo.cxx:1923
 TStreamerInfo.cxx:1924
 TStreamerInfo.cxx:1925
 TStreamerInfo.cxx:1926
 TStreamerInfo.cxx:1927
 TStreamerInfo.cxx:1928
 TStreamerInfo.cxx:1929
 TStreamerInfo.cxx:1930
 TStreamerInfo.cxx:1931
 TStreamerInfo.cxx:1932
 TStreamerInfo.cxx:1933
 TStreamerInfo.cxx:1934
 TStreamerInfo.cxx:1935
 TStreamerInfo.cxx:1936
 TStreamerInfo.cxx:1937
 TStreamerInfo.cxx:1938
 TStreamerInfo.cxx:1939
 TStreamerInfo.cxx:1940
 TStreamerInfo.cxx:1941
 TStreamerInfo.cxx:1942
 TStreamerInfo.cxx:1943
 TStreamerInfo.cxx:1944
 TStreamerInfo.cxx:1945
 TStreamerInfo.cxx:1946
 TStreamerInfo.cxx:1947
 TStreamerInfo.cxx:1948
 TStreamerInfo.cxx:1949
 TStreamerInfo.cxx:1950
 TStreamerInfo.cxx:1951
 TStreamerInfo.cxx:1952
 TStreamerInfo.cxx:1953
 TStreamerInfo.cxx:1954
 TStreamerInfo.cxx:1955
 TStreamerInfo.cxx:1956
 TStreamerInfo.cxx:1957
 TStreamerInfo.cxx:1958
 TStreamerInfo.cxx:1959
 TStreamerInfo.cxx:1960
 TStreamerInfo.cxx:1961
 TStreamerInfo.cxx:1962
 TStreamerInfo.cxx:1963
 TStreamerInfo.cxx:1964
 TStreamerInfo.cxx:1965
 TStreamerInfo.cxx:1966
 TStreamerInfo.cxx:1967
 TStreamerInfo.cxx:1968
 TStreamerInfo.cxx:1969
 TStreamerInfo.cxx:1970
 TStreamerInfo.cxx:1971
 TStreamerInfo.cxx:1972
 TStreamerInfo.cxx:1973
 TStreamerInfo.cxx:1974
 TStreamerInfo.cxx:1975
 TStreamerInfo.cxx:1976
 TStreamerInfo.cxx:1977
 TStreamerInfo.cxx:1978
 TStreamerInfo.cxx:1979
 TStreamerInfo.cxx:1980
 TStreamerInfo.cxx:1981
 TStreamerInfo.cxx:1982
 TStreamerInfo.cxx:1983
 TStreamerInfo.cxx:1984
 TStreamerInfo.cxx:1985
 TStreamerInfo.cxx:1986
 TStreamerInfo.cxx:1987
 TStreamerInfo.cxx:1988
 TStreamerInfo.cxx:1989
 TStreamerInfo.cxx:1990
 TStreamerInfo.cxx:1991
 TStreamerInfo.cxx:1992
 TStreamerInfo.cxx:1993
 TStreamerInfo.cxx:1994
 TStreamerInfo.cxx:1995
 TStreamerInfo.cxx:1996
 TStreamerInfo.cxx:1997
 TStreamerInfo.cxx:1998
 TStreamerInfo.cxx:1999
 TStreamerInfo.cxx:2000
 TStreamerInfo.cxx:2001
 TStreamerInfo.cxx:2002
 TStreamerInfo.cxx:2003
 TStreamerInfo.cxx:2004
 TStreamerInfo.cxx:2005
 TStreamerInfo.cxx:2006
 TStreamerInfo.cxx:2007
 TStreamerInfo.cxx:2008
 TStreamerInfo.cxx:2009
 TStreamerInfo.cxx:2010
 TStreamerInfo.cxx:2011
 TStreamerInfo.cxx:2012
 TStreamerInfo.cxx:2013
 TStreamerInfo.cxx:2014
 TStreamerInfo.cxx:2015
 TStreamerInfo.cxx:2016
 TStreamerInfo.cxx:2017
 TStreamerInfo.cxx:2018
 TStreamerInfo.cxx:2019
 TStreamerInfo.cxx:2020
 TStreamerInfo.cxx:2021
 TStreamerInfo.cxx:2022
 TStreamerInfo.cxx:2023
 TStreamerInfo.cxx:2024
 TStreamerInfo.cxx:2025
 TStreamerInfo.cxx:2026
 TStreamerInfo.cxx:2027
 TStreamerInfo.cxx:2028
 TStreamerInfo.cxx:2029
 TStreamerInfo.cxx:2030
 TStreamerInfo.cxx:2031
 TStreamerInfo.cxx:2032
 TStreamerInfo.cxx:2033
 TStreamerInfo.cxx:2034
 TStreamerInfo.cxx:2035
 TStreamerInfo.cxx:2036
 TStreamerInfo.cxx:2037
 TStreamerInfo.cxx:2038
 TStreamerInfo.cxx:2039
 TStreamerInfo.cxx:2040
 TStreamerInfo.cxx:2041
 TStreamerInfo.cxx:2042
 TStreamerInfo.cxx:2043
 TStreamerInfo.cxx:2044
 TStreamerInfo.cxx:2045
 TStreamerInfo.cxx:2046
 TStreamerInfo.cxx:2047
 TStreamerInfo.cxx:2048
 TStreamerInfo.cxx:2049
 TStreamerInfo.cxx:2050
 TStreamerInfo.cxx:2051
 TStreamerInfo.cxx:2052
 TStreamerInfo.cxx:2053
 TStreamerInfo.cxx:2054
 TStreamerInfo.cxx:2055
 TStreamerInfo.cxx:2056
 TStreamerInfo.cxx:2057
 TStreamerInfo.cxx:2058
 TStreamerInfo.cxx:2059
 TStreamerInfo.cxx:2060
 TStreamerInfo.cxx:2061
 TStreamerInfo.cxx:2062
 TStreamerInfo.cxx:2063
 TStreamerInfo.cxx:2064
 TStreamerInfo.cxx:2065
 TStreamerInfo.cxx:2066
 TStreamerInfo.cxx:2067
 TStreamerInfo.cxx:2068
 TStreamerInfo.cxx:2069
 TStreamerInfo.cxx:2070
 TStreamerInfo.cxx:2071
 TStreamerInfo.cxx:2072
 TStreamerInfo.cxx:2073
 TStreamerInfo.cxx:2074
 TStreamerInfo.cxx:2075
 TStreamerInfo.cxx:2076
 TStreamerInfo.cxx:2077
 TStreamerInfo.cxx:2078
 TStreamerInfo.cxx:2079
 TStreamerInfo.cxx:2080
 TStreamerInfo.cxx:2081
 TStreamerInfo.cxx:2082
 TStreamerInfo.cxx:2083
 TStreamerInfo.cxx:2084
 TStreamerInfo.cxx:2085
 TStreamerInfo.cxx:2086
 TStreamerInfo.cxx:2087
 TStreamerInfo.cxx:2088
 TStreamerInfo.cxx:2089
 TStreamerInfo.cxx:2090
 TStreamerInfo.cxx:2091
 TStreamerInfo.cxx:2092
 TStreamerInfo.cxx:2093
 TStreamerInfo.cxx:2094
 TStreamerInfo.cxx:2095
 TStreamerInfo.cxx:2096
 TStreamerInfo.cxx:2097
 TStreamerInfo.cxx:2098
 TStreamerInfo.cxx:2099
 TStreamerInfo.cxx:2100
 TStreamerInfo.cxx:2101
 TStreamerInfo.cxx:2102
 TStreamerInfo.cxx:2103
 TStreamerInfo.cxx:2104
 TStreamerInfo.cxx:2105
 TStreamerInfo.cxx:2106
 TStreamerInfo.cxx:2107
 TStreamerInfo.cxx:2108
 TStreamerInfo.cxx:2109
 TStreamerInfo.cxx:2110
 TStreamerInfo.cxx:2111
 TStreamerInfo.cxx:2112
 TStreamerInfo.cxx:2113
 TStreamerInfo.cxx:2114
 TStreamerInfo.cxx:2115
 TStreamerInfo.cxx:2116
 TStreamerInfo.cxx:2117
 TStreamerInfo.cxx:2118
 TStreamerInfo.cxx:2119
 TStreamerInfo.cxx:2120
 TStreamerInfo.cxx:2121
 TStreamerInfo.cxx:2122
 TStreamerInfo.cxx:2123
 TStreamerInfo.cxx:2124
 TStreamerInfo.cxx:2125
 TStreamerInfo.cxx:2126
 TStreamerInfo.cxx:2127
 TStreamerInfo.cxx:2128
 TStreamerInfo.cxx:2129
 TStreamerInfo.cxx:2130
 TStreamerInfo.cxx:2131
 TStreamerInfo.cxx:2132
 TStreamerInfo.cxx:2133
 TStreamerInfo.cxx:2134
 TStreamerInfo.cxx:2135
 TStreamerInfo.cxx:2136
 TStreamerInfo.cxx:2137
 TStreamerInfo.cxx:2138
 TStreamerInfo.cxx:2139
 TStreamerInfo.cxx:2140
 TStreamerInfo.cxx:2141
 TStreamerInfo.cxx:2142
 TStreamerInfo.cxx:2143
 TStreamerInfo.cxx:2144
 TStreamerInfo.cxx:2145
 TStreamerInfo.cxx:2146
 TStreamerInfo.cxx:2147
 TStreamerInfo.cxx:2148
 TStreamerInfo.cxx:2149
 TStreamerInfo.cxx:2150
 TStreamerInfo.cxx:2151
 TStreamerInfo.cxx:2152
 TStreamerInfo.cxx:2153
 TStreamerInfo.cxx:2154
 TStreamerInfo.cxx:2155
 TStreamerInfo.cxx:2156
 TStreamerInfo.cxx:2157
 TStreamerInfo.cxx:2158
 TStreamerInfo.cxx:2159
 TStreamerInfo.cxx:2160
 TStreamerInfo.cxx:2161
 TStreamerInfo.cxx:2162
 TStreamerInfo.cxx:2163
 TStreamerInfo.cxx:2164
 TStreamerInfo.cxx:2165
 TStreamerInfo.cxx:2166
 TStreamerInfo.cxx:2167
 TStreamerInfo.cxx:2168
 TStreamerInfo.cxx:2169
 TStreamerInfo.cxx:2170
 TStreamerInfo.cxx:2171
 TStreamerInfo.cxx:2172
 TStreamerInfo.cxx:2173
 TStreamerInfo.cxx:2174
 TStreamerInfo.cxx:2175
 TStreamerInfo.cxx:2176
 TStreamerInfo.cxx:2177
 TStreamerInfo.cxx:2178
 TStreamerInfo.cxx:2179
 TStreamerInfo.cxx:2180
 TStreamerInfo.cxx:2181
 TStreamerInfo.cxx:2182
 TStreamerInfo.cxx:2183
 TStreamerInfo.cxx:2184
 TStreamerInfo.cxx:2185
 TStreamerInfo.cxx:2186
 TStreamerInfo.cxx:2187
 TStreamerInfo.cxx:2188
 TStreamerInfo.cxx:2189
 TStreamerInfo.cxx:2190
 TStreamerInfo.cxx:2191
 TStreamerInfo.cxx:2192
 TStreamerInfo.cxx:2193
 TStreamerInfo.cxx:2194
 TStreamerInfo.cxx:2195
 TStreamerInfo.cxx:2196
 TStreamerInfo.cxx:2197
 TStreamerInfo.cxx:2198
 TStreamerInfo.cxx:2199
 TStreamerInfo.cxx:2200
 TStreamerInfo.cxx:2201
 TStreamerInfo.cxx:2202
 TStreamerInfo.cxx:2203
 TStreamerInfo.cxx:2204
 TStreamerInfo.cxx:2205
 TStreamerInfo.cxx:2206
 TStreamerInfo.cxx:2207
 TStreamerInfo.cxx:2208
 TStreamerInfo.cxx:2209
 TStreamerInfo.cxx:2210
 TStreamerInfo.cxx:2211
 TStreamerInfo.cxx:2212
 TStreamerInfo.cxx:2213
 TStreamerInfo.cxx:2214
 TStreamerInfo.cxx:2215
 TStreamerInfo.cxx:2216
 TStreamerInfo.cxx:2217
 TStreamerInfo.cxx:2218
 TStreamerInfo.cxx:2219
 TStreamerInfo.cxx:2220
 TStreamerInfo.cxx:2221
 TStreamerInfo.cxx:2222
 TStreamerInfo.cxx:2223
 TStreamerInfo.cxx:2224
 TStreamerInfo.cxx:2225
 TStreamerInfo.cxx:2226
 TStreamerInfo.cxx:2227
 TStreamerInfo.cxx:2228
 TStreamerInfo.cxx:2229
 TStreamerInfo.cxx:2230
 TStreamerInfo.cxx:2231
 TStreamerInfo.cxx:2232
 TStreamerInfo.cxx:2233
 TStreamerInfo.cxx:2234
 TStreamerInfo.cxx:2235
 TStreamerInfo.cxx:2236
 TStreamerInfo.cxx:2237
 TStreamerInfo.cxx:2238
 TStreamerInfo.cxx:2239
 TStreamerInfo.cxx:2240
 TStreamerInfo.cxx:2241
 TStreamerInfo.cxx:2242
 TStreamerInfo.cxx:2243
 TStreamerInfo.cxx:2244
 TStreamerInfo.cxx:2245
 TStreamerInfo.cxx:2246
 TStreamerInfo.cxx:2247
 TStreamerInfo.cxx:2248
 TStreamerInfo.cxx:2249
 TStreamerInfo.cxx:2250
 TStreamerInfo.cxx:2251
 TStreamerInfo.cxx:2252
 TStreamerInfo.cxx:2253
 TStreamerInfo.cxx:2254
 TStreamerInfo.cxx:2255
 TStreamerInfo.cxx:2256
 TStreamerInfo.cxx:2257
 TStreamerInfo.cxx:2258
 TStreamerInfo.cxx:2259
 TStreamerInfo.cxx:2260
 TStreamerInfo.cxx:2261
 TStreamerInfo.cxx:2262
 TStreamerInfo.cxx:2263
 TStreamerInfo.cxx:2264
 TStreamerInfo.cxx:2265
 TStreamerInfo.cxx:2266
 TStreamerInfo.cxx:2267
 TStreamerInfo.cxx:2268
 TStreamerInfo.cxx:2269
 TStreamerInfo.cxx:2270
 TStreamerInfo.cxx:2271
 TStreamerInfo.cxx:2272
 TStreamerInfo.cxx:2273
 TStreamerInfo.cxx:2274
 TStreamerInfo.cxx:2275
 TStreamerInfo.cxx:2276
 TStreamerInfo.cxx:2277
 TStreamerInfo.cxx:2278
 TStreamerInfo.cxx:2279
 TStreamerInfo.cxx:2280
 TStreamerInfo.cxx:2281
 TStreamerInfo.cxx:2282
 TStreamerInfo.cxx:2283
 TStreamerInfo.cxx:2284
 TStreamerInfo.cxx:2285
 TStreamerInfo.cxx:2286
 TStreamerInfo.cxx:2287
 TStreamerInfo.cxx:2288
 TStreamerInfo.cxx:2289
 TStreamerInfo.cxx:2290
 TStreamerInfo.cxx:2291
 TStreamerInfo.cxx:2292
 TStreamerInfo.cxx:2293
 TStreamerInfo.cxx:2294
 TStreamerInfo.cxx:2295
 TStreamerInfo.cxx:2296
 TStreamerInfo.cxx:2297
 TStreamerInfo.cxx:2298
 TStreamerInfo.cxx:2299
 TStreamerInfo.cxx:2300
 TStreamerInfo.cxx:2301
 TStreamerInfo.cxx:2302
 TStreamerInfo.cxx:2303
 TStreamerInfo.cxx:2304
 TStreamerInfo.cxx:2305
 TStreamerInfo.cxx:2306
 TStreamerInfo.cxx:2307
 TStreamerInfo.cxx:2308
 TStreamerInfo.cxx:2309
 TStreamerInfo.cxx:2310
 TStreamerInfo.cxx:2311
 TStreamerInfo.cxx:2312
 TStreamerInfo.cxx:2313
 TStreamerInfo.cxx:2314
 TStreamerInfo.cxx:2315
 TStreamerInfo.cxx:2316
 TStreamerInfo.cxx:2317
 TStreamerInfo.cxx:2318
 TStreamerInfo.cxx:2319
 TStreamerInfo.cxx:2320
 TStreamerInfo.cxx:2321
 TStreamerInfo.cxx:2322
 TStreamerInfo.cxx:2323
 TStreamerInfo.cxx:2324
 TStreamerInfo.cxx:2325
 TStreamerInfo.cxx:2326
 TStreamerInfo.cxx:2327
 TStreamerInfo.cxx:2328
 TStreamerInfo.cxx:2329
 TStreamerInfo.cxx:2330
 TStreamerInfo.cxx:2331
 TStreamerInfo.cxx:2332
 TStreamerInfo.cxx:2333
 TStreamerInfo.cxx:2334
 TStreamerInfo.cxx:2335
 TStreamerInfo.cxx:2336
 TStreamerInfo.cxx:2337
 TStreamerInfo.cxx:2338
 TStreamerInfo.cxx:2339
 TStreamerInfo.cxx:2340
 TStreamerInfo.cxx:2341
 TStreamerInfo.cxx:2342
 TStreamerInfo.cxx:2343
 TStreamerInfo.cxx:2344
 TStreamerInfo.cxx:2345
 TStreamerInfo.cxx:2346
 TStreamerInfo.cxx:2347
 TStreamerInfo.cxx:2348
 TStreamerInfo.cxx:2349
 TStreamerInfo.cxx:2350
 TStreamerInfo.cxx:2351
 TStreamerInfo.cxx:2352
 TStreamerInfo.cxx:2353
 TStreamerInfo.cxx:2354
 TStreamerInfo.cxx:2355
 TStreamerInfo.cxx:2356
 TStreamerInfo.cxx:2357
 TStreamerInfo.cxx:2358
 TStreamerInfo.cxx:2359
 TStreamerInfo.cxx:2360
 TStreamerInfo.cxx:2361
 TStreamerInfo.cxx:2362
 TStreamerInfo.cxx:2363
 TStreamerInfo.cxx:2364
 TStreamerInfo.cxx:2365
 TStreamerInfo.cxx:2366
 TStreamerInfo.cxx:2367
 TStreamerInfo.cxx:2368
 TStreamerInfo.cxx:2369
 TStreamerInfo.cxx:2370
 TStreamerInfo.cxx:2371
 TStreamerInfo.cxx:2372
 TStreamerInfo.cxx:2373
 TStreamerInfo.cxx:2374
 TStreamerInfo.cxx:2375
 TStreamerInfo.cxx:2376
 TStreamerInfo.cxx:2377
 TStreamerInfo.cxx:2378
 TStreamerInfo.cxx:2379
 TStreamerInfo.cxx:2380
 TStreamerInfo.cxx:2381
 TStreamerInfo.cxx:2382
 TStreamerInfo.cxx:2383
 TStreamerInfo.cxx:2384
 TStreamerInfo.cxx:2385
 TStreamerInfo.cxx:2386
 TStreamerInfo.cxx:2387
 TStreamerInfo.cxx:2388
 TStreamerInfo.cxx:2389
 TStreamerInfo.cxx:2390
 TStreamerInfo.cxx:2391
 TStreamerInfo.cxx:2392
 TStreamerInfo.cxx:2393
 TStreamerInfo.cxx:2394
 TStreamerInfo.cxx:2395
 TStreamerInfo.cxx:2396
 TStreamerInfo.cxx:2397
 TStreamerInfo.cxx:2398
 TStreamerInfo.cxx:2399
 TStreamerInfo.cxx:2400
 TStreamerInfo.cxx:2401
 TStreamerInfo.cxx:2402
 TStreamerInfo.cxx:2403
 TStreamerInfo.cxx:2404
 TStreamerInfo.cxx:2405
 TStreamerInfo.cxx:2406
 TStreamerInfo.cxx:2407
 TStreamerInfo.cxx:2408
 TStreamerInfo.cxx:2409
 TStreamerInfo.cxx:2410
 TStreamerInfo.cxx:2411
 TStreamerInfo.cxx:2412
 TStreamerInfo.cxx:2413
 TStreamerInfo.cxx:2414
 TStreamerInfo.cxx:2415
 TStreamerInfo.cxx:2416
 TStreamerInfo.cxx:2417
 TStreamerInfo.cxx:2418
 TStreamerInfo.cxx:2419
 TStreamerInfo.cxx:2420
 TStreamerInfo.cxx:2421
 TStreamerInfo.cxx:2422
 TStreamerInfo.cxx:2423
 TStreamerInfo.cxx:2424
 TStreamerInfo.cxx:2425
 TStreamerInfo.cxx:2426
 TStreamerInfo.cxx:2427
 TStreamerInfo.cxx:2428
 TStreamerInfo.cxx:2429
 TStreamerInfo.cxx:2430
 TStreamerInfo.cxx:2431
 TStreamerInfo.cxx:2432
 TStreamerInfo.cxx:2433
 TStreamerInfo.cxx:2434
 TStreamerInfo.cxx:2435
 TStreamerInfo.cxx:2436
 TStreamerInfo.cxx:2437
 TStreamerInfo.cxx:2438
 TStreamerInfo.cxx:2439
 TStreamerInfo.cxx:2440
 TStreamerInfo.cxx:2441
 TStreamerInfo.cxx:2442
 TStreamerInfo.cxx:2443
 TStreamerInfo.cxx:2444
 TStreamerInfo.cxx:2445
 TStreamerInfo.cxx:2446
 TStreamerInfo.cxx:2447
 TStreamerInfo.cxx:2448
 TStreamerInfo.cxx:2449
 TStreamerInfo.cxx:2450
 TStreamerInfo.cxx:2451
 TStreamerInfo.cxx:2452
 TStreamerInfo.cxx:2453
 TStreamerInfo.cxx:2454
 TStreamerInfo.cxx:2455
 TStreamerInfo.cxx:2456
 TStreamerInfo.cxx:2457
 TStreamerInfo.cxx:2458
 TStreamerInfo.cxx:2459
 TStreamerInfo.cxx:2460
 TStreamerInfo.cxx:2461
 TStreamerInfo.cxx:2462
 TStreamerInfo.cxx:2463
 TStreamerInfo.cxx:2464
 TStreamerInfo.cxx:2465
 TStreamerInfo.cxx:2466
 TStreamerInfo.cxx:2467
 TStreamerInfo.cxx:2468
 TStreamerInfo.cxx:2469
 TStreamerInfo.cxx:2470
 TStreamerInfo.cxx:2471
 TStreamerInfo.cxx:2472
 TStreamerInfo.cxx:2473
 TStreamerInfo.cxx:2474
 TStreamerInfo.cxx:2475
 TStreamerInfo.cxx:2476
 TStreamerInfo.cxx:2477
 TStreamerInfo.cxx:2478
 TStreamerInfo.cxx:2479
 TStreamerInfo.cxx:2480
 TStreamerInfo.cxx:2481
 TStreamerInfo.cxx:2482
 TStreamerInfo.cxx:2483
 TStreamerInfo.cxx:2484
 TStreamerInfo.cxx:2485
 TStreamerInfo.cxx:2486
 TStreamerInfo.cxx:2487
 TStreamerInfo.cxx:2488
 TStreamerInfo.cxx:2489
 TStreamerInfo.cxx:2490
 TStreamerInfo.cxx:2491
 TStreamerInfo.cxx:2492
 TStreamerInfo.cxx:2493
 TStreamerInfo.cxx:2494
 TStreamerInfo.cxx:2495
 TStreamerInfo.cxx:2496
 TStreamerInfo.cxx:2497
 TStreamerInfo.cxx:2498
 TStreamerInfo.cxx:2499
 TStreamerInfo.cxx:2500
 TStreamerInfo.cxx:2501
 TStreamerInfo.cxx:2502
 TStreamerInfo.cxx:2503
 TStreamerInfo.cxx:2504
 TStreamerInfo.cxx:2505
 TStreamerInfo.cxx:2506
 TStreamerInfo.cxx:2507
 TStreamerInfo.cxx:2508
 TStreamerInfo.cxx:2509
 TStreamerInfo.cxx:2510
 TStreamerInfo.cxx:2511
 TStreamerInfo.cxx:2512
 TStreamerInfo.cxx:2513
 TStreamerInfo.cxx:2514
 TStreamerInfo.cxx:2515
 TStreamerInfo.cxx:2516
 TStreamerInfo.cxx:2517
 TStreamerInfo.cxx:2518
 TStreamerInfo.cxx:2519
 TStreamerInfo.cxx:2520
 TStreamerInfo.cxx:2521
 TStreamerInfo.cxx:2522
 TStreamerInfo.cxx:2523
 TStreamerInfo.cxx:2524
 TStreamerInfo.cxx:2525
 TStreamerInfo.cxx:2526
 TStreamerInfo.cxx:2527
 TStreamerInfo.cxx:2528
 TStreamerInfo.cxx:2529
 TStreamerInfo.cxx:2530
 TStreamerInfo.cxx:2531
 TStreamerInfo.cxx:2532
 TStreamerInfo.cxx:2533
 TStreamerInfo.cxx:2534
 TStreamerInfo.cxx:2535
 TStreamerInfo.cxx:2536
 TStreamerInfo.cxx:2537
 TStreamerInfo.cxx:2538
 TStreamerInfo.cxx:2539
 TStreamerInfo.cxx:2540
 TStreamerInfo.cxx:2541
 TStreamerInfo.cxx:2542
 TStreamerInfo.cxx:2543
 TStreamerInfo.cxx:2544
 TStreamerInfo.cxx:2545
 TStreamerInfo.cxx:2546
 TStreamerInfo.cxx:2547
 TStreamerInfo.cxx:2548
 TStreamerInfo.cxx:2549
 TStreamerInfo.cxx:2550
 TStreamerInfo.cxx:2551
 TStreamerInfo.cxx:2552
 TStreamerInfo.cxx:2553
 TStreamerInfo.cxx:2554
 TStreamerInfo.cxx:2555
 TStreamerInfo.cxx:2556
 TStreamerInfo.cxx:2557
 TStreamerInfo.cxx:2558
 TStreamerInfo.cxx:2559
 TStreamerInfo.cxx:2560
 TStreamerInfo.cxx:2561
 TStreamerInfo.cxx:2562
 TStreamerInfo.cxx:2563
 TStreamerInfo.cxx:2564
 TStreamerInfo.cxx:2565
 TStreamerInfo.cxx:2566
 TStreamerInfo.cxx:2567
 TStreamerInfo.cxx:2568
 TStreamerInfo.cxx:2569
 TStreamerInfo.cxx:2570
 TStreamerInfo.cxx:2571
 TStreamerInfo.cxx:2572
 TStreamerInfo.cxx:2573
 TStreamerInfo.cxx:2574
 TStreamerInfo.cxx:2575
 TStreamerInfo.cxx:2576
 TStreamerInfo.cxx:2577
 TStreamerInfo.cxx:2578
 TStreamerInfo.cxx:2579
 TStreamerInfo.cxx:2580
 TStreamerInfo.cxx:2581
 TStreamerInfo.cxx:2582
 TStreamerInfo.cxx:2583
 TStreamerInfo.cxx:2584
 TStreamerInfo.cxx:2585
 TStreamerInfo.cxx:2586
 TStreamerInfo.cxx:2587
 TStreamerInfo.cxx:2588
 TStreamerInfo.cxx:2589
 TStreamerInfo.cxx:2590
 TStreamerInfo.cxx:2591
 TStreamerInfo.cxx:2592
 TStreamerInfo.cxx:2593
 TStreamerInfo.cxx:2594
 TStreamerInfo.cxx:2595
 TStreamerInfo.cxx:2596
 TStreamerInfo.cxx:2597
 TStreamerInfo.cxx:2598
 TStreamerInfo.cxx:2599
 TStreamerInfo.cxx:2600
 TStreamerInfo.cxx:2601
 TStreamerInfo.cxx:2602
 TStreamerInfo.cxx:2603
 TStreamerInfo.cxx:2604
 TStreamerInfo.cxx:2605
 TStreamerInfo.cxx:2606
 TStreamerInfo.cxx:2607
 TStreamerInfo.cxx:2608
 TStreamerInfo.cxx:2609
 TStreamerInfo.cxx:2610
 TStreamerInfo.cxx:2611
 TStreamerInfo.cxx:2612
 TStreamerInfo.cxx:2613
 TStreamerInfo.cxx:2614
 TStreamerInfo.cxx:2615
 TStreamerInfo.cxx:2616
 TStreamerInfo.cxx:2617
 TStreamerInfo.cxx:2618
 TStreamerInfo.cxx:2619
 TStreamerInfo.cxx:2620
 TStreamerInfo.cxx:2621
 TStreamerInfo.cxx:2622
 TStreamerInfo.cxx:2623
 TStreamerInfo.cxx:2624
 TStreamerInfo.cxx:2625
 TStreamerInfo.cxx:2626
 TStreamerInfo.cxx:2627
 TStreamerInfo.cxx:2628
 TStreamerInfo.cxx:2629
 TStreamerInfo.cxx:2630
 TStreamerInfo.cxx:2631
 TStreamerInfo.cxx:2632
 TStreamerInfo.cxx:2633
 TStreamerInfo.cxx:2634
 TStreamerInfo.cxx:2635
 TStreamerInfo.cxx:2636
 TStreamerInfo.cxx:2637
 TStreamerInfo.cxx:2638
 TStreamerInfo.cxx:2639
 TStreamerInfo.cxx:2640
 TStreamerInfo.cxx:2641
 TStreamerInfo.cxx:2642
 TStreamerInfo.cxx:2643
 TStreamerInfo.cxx:2644
 TStreamerInfo.cxx:2645
 TStreamerInfo.cxx:2646
 TStreamerInfo.cxx:2647
 TStreamerInfo.cxx:2648
 TStreamerInfo.cxx:2649
 TStreamerInfo.cxx:2650
 TStreamerInfo.cxx:2651
 TStreamerInfo.cxx:2652
 TStreamerInfo.cxx:2653
 TStreamerInfo.cxx:2654
 TStreamerInfo.cxx:2655
 TStreamerInfo.cxx:2656
 TStreamerInfo.cxx:2657
 TStreamerInfo.cxx:2658
 TStreamerInfo.cxx:2659
 TStreamerInfo.cxx:2660
 TStreamerInfo.cxx:2661
 TStreamerInfo.cxx:2662
 TStreamerInfo.cxx:2663
 TStreamerInfo.cxx:2664
 TStreamerInfo.cxx:2665
 TStreamerInfo.cxx:2666
 TStreamerInfo.cxx:2667
 TStreamerInfo.cxx:2668
 TStreamerInfo.cxx:2669
 TStreamerInfo.cxx:2670
 TStreamerInfo.cxx:2671
 TStreamerInfo.cxx:2672
 TStreamerInfo.cxx:2673
 TStreamerInfo.cxx:2674
 TStreamerInfo.cxx:2675
 TStreamerInfo.cxx:2676
 TStreamerInfo.cxx:2677
 TStreamerInfo.cxx:2678
 TStreamerInfo.cxx:2679
 TStreamerInfo.cxx:2680
 TStreamerInfo.cxx:2681
 TStreamerInfo.cxx:2682
 TStreamerInfo.cxx:2683
 TStreamerInfo.cxx:2684
 TStreamerInfo.cxx:2685
 TStreamerInfo.cxx:2686
 TStreamerInfo.cxx:2687
 TStreamerInfo.cxx:2688
 TStreamerInfo.cxx:2689
 TStreamerInfo.cxx:2690
 TStreamerInfo.cxx:2691
 TStreamerInfo.cxx:2692
 TStreamerInfo.cxx:2693
 TStreamerInfo.cxx:2694
 TStreamerInfo.cxx:2695
 TStreamerInfo.cxx:2696
 TStreamerInfo.cxx:2697
 TStreamerInfo.cxx:2698
 TStreamerInfo.cxx:2699
 TStreamerInfo.cxx:2700
 TStreamerInfo.cxx:2701
 TStreamerInfo.cxx:2702
 TStreamerInfo.cxx:2703
 TStreamerInfo.cxx:2704
 TStreamerInfo.cxx:2705
 TStreamerInfo.cxx:2706
 TStreamerInfo.cxx:2707
 TStreamerInfo.cxx:2708
 TStreamerInfo.cxx:2709
 TStreamerInfo.cxx:2710
 TStreamerInfo.cxx:2711
 TStreamerInfo.cxx:2712
 TStreamerInfo.cxx:2713
 TStreamerInfo.cxx:2714
 TStreamerInfo.cxx:2715
 TStreamerInfo.cxx:2716
 TStreamerInfo.cxx:2717
 TStreamerInfo.cxx:2718
 TStreamerInfo.cxx:2719
 TStreamerInfo.cxx:2720
 TStreamerInfo.cxx:2721
 TStreamerInfo.cxx:2722
 TStreamerInfo.cxx:2723
 TStreamerInfo.cxx:2724
 TStreamerInfo.cxx:2725
 TStreamerInfo.cxx:2726
 TStreamerInfo.cxx:2727
 TStreamerInfo.cxx:2728
 TStreamerInfo.cxx:2729
 TStreamerInfo.cxx:2730
 TStreamerInfo.cxx:2731
 TStreamerInfo.cxx:2732
 TStreamerInfo.cxx:2733
 TStreamerInfo.cxx:2734
 TStreamerInfo.cxx:2735
 TStreamerInfo.cxx:2736
 TStreamerInfo.cxx:2737
 TStreamerInfo.cxx:2738
 TStreamerInfo.cxx:2739
 TStreamerInfo.cxx:2740
 TStreamerInfo.cxx:2741
 TStreamerInfo.cxx:2742
 TStreamerInfo.cxx:2743
 TStreamerInfo.cxx:2744
 TStreamerInfo.cxx:2745
 TStreamerInfo.cxx:2746
 TStreamerInfo.cxx:2747
 TStreamerInfo.cxx:2748
 TStreamerInfo.cxx:2749
 TStreamerInfo.cxx:2750
 TStreamerInfo.cxx:2751
 TStreamerInfo.cxx:2752
 TStreamerInfo.cxx:2753
 TStreamerInfo.cxx:2754
 TStreamerInfo.cxx:2755
 TStreamerInfo.cxx:2756
 TStreamerInfo.cxx:2757
 TStreamerInfo.cxx:2758
 TStreamerInfo.cxx:2759
 TStreamerInfo.cxx:2760
 TStreamerInfo.cxx:2761
 TStreamerInfo.cxx:2762
 TStreamerInfo.cxx:2763
 TStreamerInfo.cxx:2764
 TStreamerInfo.cxx:2765
 TStreamerInfo.cxx:2766
 TStreamerInfo.cxx:2767
 TStreamerInfo.cxx:2768
 TStreamerInfo.cxx:2769
 TStreamerInfo.cxx:2770
 TStreamerInfo.cxx:2771
 TStreamerInfo.cxx:2772
 TStreamerInfo.cxx:2773
 TStreamerInfo.cxx:2774
 TStreamerInfo.cxx:2775
 TStreamerInfo.cxx:2776
 TStreamerInfo.cxx:2777
 TStreamerInfo.cxx:2778
 TStreamerInfo.cxx:2779
 TStreamerInfo.cxx:2780
 TStreamerInfo.cxx:2781
 TStreamerInfo.cxx:2782
 TStreamerInfo.cxx:2783
 TStreamerInfo.cxx:2784
 TStreamerInfo.cxx:2785
 TStreamerInfo.cxx:2786
 TStreamerInfo.cxx:2787
 TStreamerInfo.cxx:2788
 TStreamerInfo.cxx:2789
 TStreamerInfo.cxx:2790
 TStreamerInfo.cxx:2791
 TStreamerInfo.cxx:2792
 TStreamerInfo.cxx:2793
 TStreamerInfo.cxx:2794
 TStreamerInfo.cxx:2795
 TStreamerInfo.cxx:2796
 TStreamerInfo.cxx:2797
 TStreamerInfo.cxx:2798
 TStreamerInfo.cxx:2799
 TStreamerInfo.cxx:2800
 TStreamerInfo.cxx:2801
 TStreamerInfo.cxx:2802
 TStreamerInfo.cxx:2803
 TStreamerInfo.cxx:2804
 TStreamerInfo.cxx:2805
 TStreamerInfo.cxx:2806
 TStreamerInfo.cxx:2807
 TStreamerInfo.cxx:2808
 TStreamerInfo.cxx:2809
 TStreamerInfo.cxx:2810
 TStreamerInfo.cxx:2811
 TStreamerInfo.cxx:2812
 TStreamerInfo.cxx:2813
 TStreamerInfo.cxx:2814
 TStreamerInfo.cxx:2815
 TStreamerInfo.cxx:2816
 TStreamerInfo.cxx:2817
 TStreamerInfo.cxx:2818
 TStreamerInfo.cxx:2819
 TStreamerInfo.cxx:2820
 TStreamerInfo.cxx:2821
 TStreamerInfo.cxx:2822
 TStreamerInfo.cxx:2823
 TStreamerInfo.cxx:2824
 TStreamerInfo.cxx:2825
 TStreamerInfo.cxx:2826
 TStreamerInfo.cxx:2827
 TStreamerInfo.cxx:2828
 TStreamerInfo.cxx:2829
 TStreamerInfo.cxx:2830
 TStreamerInfo.cxx:2831
 TStreamerInfo.cxx:2832
 TStreamerInfo.cxx:2833
 TStreamerInfo.cxx:2834
 TStreamerInfo.cxx:2835
 TStreamerInfo.cxx:2836
 TStreamerInfo.cxx:2837
 TStreamerInfo.cxx:2838
 TStreamerInfo.cxx:2839
 TStreamerInfo.cxx:2840
 TStreamerInfo.cxx:2841
 TStreamerInfo.cxx:2842
 TStreamerInfo.cxx:2843
 TStreamerInfo.cxx:2844
 TStreamerInfo.cxx:2845
 TStreamerInfo.cxx:2846
 TStreamerInfo.cxx:2847
 TStreamerInfo.cxx:2848
 TStreamerInfo.cxx:2849
 TStreamerInfo.cxx:2850
 TStreamerInfo.cxx:2851
 TStreamerInfo.cxx:2852
 TStreamerInfo.cxx:2853
 TStreamerInfo.cxx:2854
 TStreamerInfo.cxx:2855
 TStreamerInfo.cxx:2856
 TStreamerInfo.cxx:2857
 TStreamerInfo.cxx:2858
 TStreamerInfo.cxx:2859
 TStreamerInfo.cxx:2860
 TStreamerInfo.cxx:2861
 TStreamerInfo.cxx:2862
 TStreamerInfo.cxx:2863
 TStreamerInfo.cxx:2864
 TStreamerInfo.cxx:2865
 TStreamerInfo.cxx:2866
 TStreamerInfo.cxx:2867
 TStreamerInfo.cxx:2868
 TStreamerInfo.cxx:2869
 TStreamerInfo.cxx:2870
 TStreamerInfo.cxx:2871
 TStreamerInfo.cxx:2872
 TStreamerInfo.cxx:2873
 TStreamerInfo.cxx:2874
 TStreamerInfo.cxx:2875
 TStreamerInfo.cxx:2876
 TStreamerInfo.cxx:2877
 TStreamerInfo.cxx:2878
 TStreamerInfo.cxx:2879
 TStreamerInfo.cxx:2880
 TStreamerInfo.cxx:2881
 TStreamerInfo.cxx:2882
 TStreamerInfo.cxx:2883
 TStreamerInfo.cxx:2884
 TStreamerInfo.cxx:2885
 TStreamerInfo.cxx:2886
 TStreamerInfo.cxx:2887
 TStreamerInfo.cxx:2888
 TStreamerInfo.cxx:2889
 TStreamerInfo.cxx:2890
 TStreamerInfo.cxx:2891
 TStreamerInfo.cxx:2892
 TStreamerInfo.cxx:2893
 TStreamerInfo.cxx:2894
 TStreamerInfo.cxx:2895
 TStreamerInfo.cxx:2896
 TStreamerInfo.cxx:2897
 TStreamerInfo.cxx:2898
 TStreamerInfo.cxx:2899
 TStreamerInfo.cxx:2900
 TStreamerInfo.cxx:2901
 TStreamerInfo.cxx:2902
 TStreamerInfo.cxx:2903
 TStreamerInfo.cxx:2904
 TStreamerInfo.cxx:2905
 TStreamerInfo.cxx:2906
 TStreamerInfo.cxx:2907
 TStreamerInfo.cxx:2908
 TStreamerInfo.cxx:2909
 TStreamerInfo.cxx:2910
 TStreamerInfo.cxx:2911
 TStreamerInfo.cxx:2912
 TStreamerInfo.cxx:2913
 TStreamerInfo.cxx:2914
 TStreamerInfo.cxx:2915
 TStreamerInfo.cxx:2916
 TStreamerInfo.cxx:2917
 TStreamerInfo.cxx:2918
 TStreamerInfo.cxx:2919
 TStreamerInfo.cxx:2920
 TStreamerInfo.cxx:2921
 TStreamerInfo.cxx:2922
 TStreamerInfo.cxx:2923
 TStreamerInfo.cxx:2924
 TStreamerInfo.cxx:2925
 TStreamerInfo.cxx:2926
 TStreamerInfo.cxx:2927
 TStreamerInfo.cxx:2928
 TStreamerInfo.cxx:2929
 TStreamerInfo.cxx:2930
 TStreamerInfo.cxx:2931
 TStreamerInfo.cxx:2932
 TStreamerInfo.cxx:2933
 TStreamerInfo.cxx:2934
 TStreamerInfo.cxx:2935
 TStreamerInfo.cxx:2936
 TStreamerInfo.cxx:2937
 TStreamerInfo.cxx:2938
 TStreamerInfo.cxx:2939
 TStreamerInfo.cxx:2940
 TStreamerInfo.cxx:2941
 TStreamerInfo.cxx:2942
 TStreamerInfo.cxx:2943
 TStreamerInfo.cxx:2944
 TStreamerInfo.cxx:2945
 TStreamerInfo.cxx:2946
 TStreamerInfo.cxx:2947
 TStreamerInfo.cxx:2948
 TStreamerInfo.cxx:2949
 TStreamerInfo.cxx:2950
 TStreamerInfo.cxx:2951
 TStreamerInfo.cxx:2952
 TStreamerInfo.cxx:2953
 TStreamerInfo.cxx:2954
 TStreamerInfo.cxx:2955
 TStreamerInfo.cxx:2956
 TStreamerInfo.cxx:2957
 TStreamerInfo.cxx:2958
 TStreamerInfo.cxx:2959
 TStreamerInfo.cxx:2960
 TStreamerInfo.cxx:2961
 TStreamerInfo.cxx:2962
 TStreamerInfo.cxx:2963
 TStreamerInfo.cxx:2964
 TStreamerInfo.cxx:2965
 TStreamerInfo.cxx:2966
 TStreamerInfo.cxx:2967
 TStreamerInfo.cxx:2968
 TStreamerInfo.cxx:2969
 TStreamerInfo.cxx:2970
 TStreamerInfo.cxx:2971
 TStreamerInfo.cxx:2972
 TStreamerInfo.cxx:2973
 TStreamerInfo.cxx:2974
 TStreamerInfo.cxx:2975
 TStreamerInfo.cxx:2976
 TStreamerInfo.cxx:2977
 TStreamerInfo.cxx:2978
 TStreamerInfo.cxx:2979
 TStreamerInfo.cxx:2980
 TStreamerInfo.cxx:2981
 TStreamerInfo.cxx:2982
 TStreamerInfo.cxx:2983
 TStreamerInfo.cxx:2984
 TStreamerInfo.cxx:2985
 TStreamerInfo.cxx:2986
 TStreamerInfo.cxx:2987
 TStreamerInfo.cxx:2988
 TStreamerInfo.cxx:2989
 TStreamerInfo.cxx:2990
 TStreamerInfo.cxx:2991
 TStreamerInfo.cxx:2992
 TStreamerInfo.cxx:2993
 TStreamerInfo.cxx:2994
 TStreamerInfo.cxx:2995
 TStreamerInfo.cxx:2996
 TStreamerInfo.cxx:2997
 TStreamerInfo.cxx:2998
 TStreamerInfo.cxx:2999
 TStreamerInfo.cxx:3000
 TStreamerInfo.cxx:3001
 TStreamerInfo.cxx:3002
 TStreamerInfo.cxx:3003
 TStreamerInfo.cxx:3004
 TStreamerInfo.cxx:3005
 TStreamerInfo.cxx:3006
 TStreamerInfo.cxx:3007
 TStreamerInfo.cxx:3008
 TStreamerInfo.cxx:3009
 TStreamerInfo.cxx:3010
 TStreamerInfo.cxx:3011
 TStreamerInfo.cxx:3012
 TStreamerInfo.cxx:3013
 TStreamerInfo.cxx:3014
 TStreamerInfo.cxx:3015
 TStreamerInfo.cxx:3016
 TStreamerInfo.cxx:3017
 TStreamerInfo.cxx:3018
 TStreamerInfo.cxx:3019
 TStreamerInfo.cxx:3020
 TStreamerInfo.cxx:3021
 TStreamerInfo.cxx:3022
 TStreamerInfo.cxx:3023
 TStreamerInfo.cxx:3024
 TStreamerInfo.cxx:3025
 TStreamerInfo.cxx:3026
 TStreamerInfo.cxx:3027
 TStreamerInfo.cxx:3028
 TStreamerInfo.cxx:3029
 TStreamerInfo.cxx:3030
 TStreamerInfo.cxx:3031
 TStreamerInfo.cxx:3032
 TStreamerInfo.cxx:3033
 TStreamerInfo.cxx:3034
 TStreamerInfo.cxx:3035
 TStreamerInfo.cxx:3036
 TStreamerInfo.cxx:3037
 TStreamerInfo.cxx:3038
 TStreamerInfo.cxx:3039
 TStreamerInfo.cxx:3040
 TStreamerInfo.cxx:3041
 TStreamerInfo.cxx:3042
 TStreamerInfo.cxx:3043
 TStreamerInfo.cxx:3044
 TStreamerInfo.cxx:3045
 TStreamerInfo.cxx:3046
 TStreamerInfo.cxx:3047
 TStreamerInfo.cxx:3048
 TStreamerInfo.cxx:3049
 TStreamerInfo.cxx:3050
 TStreamerInfo.cxx:3051
 TStreamerInfo.cxx:3052
 TStreamerInfo.cxx:3053
 TStreamerInfo.cxx:3054
 TStreamerInfo.cxx:3055
 TStreamerInfo.cxx:3056
 TStreamerInfo.cxx:3057
 TStreamerInfo.cxx:3058
 TStreamerInfo.cxx:3059
 TStreamerInfo.cxx:3060
 TStreamerInfo.cxx:3061
 TStreamerInfo.cxx:3062
 TStreamerInfo.cxx:3063
 TStreamerInfo.cxx:3064
 TStreamerInfo.cxx:3065
 TStreamerInfo.cxx:3066
 TStreamerInfo.cxx:3067
 TStreamerInfo.cxx:3068
 TStreamerInfo.cxx:3069
 TStreamerInfo.cxx:3070
 TStreamerInfo.cxx:3071
 TStreamerInfo.cxx:3072
 TStreamerInfo.cxx:3073
 TStreamerInfo.cxx:3074
 TStreamerInfo.cxx:3075
 TStreamerInfo.cxx:3076
 TStreamerInfo.cxx:3077
 TStreamerInfo.cxx:3078
 TStreamerInfo.cxx:3079
 TStreamerInfo.cxx:3080
 TStreamerInfo.cxx:3081
 TStreamerInfo.cxx:3082
 TStreamerInfo.cxx:3083
 TStreamerInfo.cxx:3084
 TStreamerInfo.cxx:3085
 TStreamerInfo.cxx:3086
 TStreamerInfo.cxx:3087
 TStreamerInfo.cxx:3088
 TStreamerInfo.cxx:3089
 TStreamerInfo.cxx:3090
 TStreamerInfo.cxx:3091
 TStreamerInfo.cxx:3092
 TStreamerInfo.cxx:3093
 TStreamerInfo.cxx:3094
 TStreamerInfo.cxx:3095
 TStreamerInfo.cxx:3096
 TStreamerInfo.cxx:3097
 TStreamerInfo.cxx:3098
 TStreamerInfo.cxx:3099
 TStreamerInfo.cxx:3100
 TStreamerInfo.cxx:3101
 TStreamerInfo.cxx:3102
 TStreamerInfo.cxx:3103
 TStreamerInfo.cxx:3104
 TStreamerInfo.cxx:3105
 TStreamerInfo.cxx:3106
 TStreamerInfo.cxx:3107
 TStreamerInfo.cxx:3108
 TStreamerInfo.cxx:3109
 TStreamerInfo.cxx:3110
 TStreamerInfo.cxx:3111
 TStreamerInfo.cxx:3112
 TStreamerInfo.cxx:3113
 TStreamerInfo.cxx:3114
 TStreamerInfo.cxx:3115
 TStreamerInfo.cxx:3116
 TStreamerInfo.cxx:3117
 TStreamerInfo.cxx:3118
 TStreamerInfo.cxx:3119
 TStreamerInfo.cxx:3120
 TStreamerInfo.cxx:3121
 TStreamerInfo.cxx:3122
 TStreamerInfo.cxx:3123
 TStreamerInfo.cxx:3124
 TStreamerInfo.cxx:3125
 TStreamerInfo.cxx:3126
 TStreamerInfo.cxx:3127
 TStreamerInfo.cxx:3128
 TStreamerInfo.cxx:3129
 TStreamerInfo.cxx:3130
 TStreamerInfo.cxx:3131
 TStreamerInfo.cxx:3132
 TStreamerInfo.cxx:3133
 TStreamerInfo.cxx:3134
 TStreamerInfo.cxx:3135
 TStreamerInfo.cxx:3136
 TStreamerInfo.cxx:3137
 TStreamerInfo.cxx:3138
 TStreamerInfo.cxx:3139
 TStreamerInfo.cxx:3140
 TStreamerInfo.cxx:3141
 TStreamerInfo.cxx:3142
 TStreamerInfo.cxx:3143
 TStreamerInfo.cxx:3144
 TStreamerInfo.cxx:3145
 TStreamerInfo.cxx:3146
 TStreamerInfo.cxx:3147
 TStreamerInfo.cxx:3148
 TStreamerInfo.cxx:3149
 TStreamerInfo.cxx:3150
 TStreamerInfo.cxx:3151
 TStreamerInfo.cxx:3152
 TStreamerInfo.cxx:3153
 TStreamerInfo.cxx:3154
 TStreamerInfo.cxx:3155
 TStreamerInfo.cxx:3156
 TStreamerInfo.cxx:3157
 TStreamerInfo.cxx:3158
 TStreamerInfo.cxx:3159
 TStreamerInfo.cxx:3160
 TStreamerInfo.cxx:3161
 TStreamerInfo.cxx:3162
 TStreamerInfo.cxx:3163
 TStreamerInfo.cxx:3164
 TStreamerInfo.cxx:3165
 TStreamerInfo.cxx:3166
 TStreamerInfo.cxx:3167
 TStreamerInfo.cxx:3168
 TStreamerInfo.cxx:3169
 TStreamerInfo.cxx:3170
 TStreamerInfo.cxx:3171
 TStreamerInfo.cxx:3172
 TStreamerInfo.cxx:3173
 TStreamerInfo.cxx:3174
 TStreamerInfo.cxx:3175
 TStreamerInfo.cxx:3176
 TStreamerInfo.cxx:3177
 TStreamerInfo.cxx:3178
 TStreamerInfo.cxx:3179
 TStreamerInfo.cxx:3180
 TStreamerInfo.cxx:3181
 TStreamerInfo.cxx:3182
 TStreamerInfo.cxx:3183
 TStreamerInfo.cxx:3184
 TStreamerInfo.cxx:3185
 TStreamerInfo.cxx:3186
 TStreamerInfo.cxx:3187
 TStreamerInfo.cxx:3188
 TStreamerInfo.cxx:3189
 TStreamerInfo.cxx:3190
 TStreamerInfo.cxx:3191
 TStreamerInfo.cxx:3192
 TStreamerInfo.cxx: