ROOT logo
// @(#)root/cont:$Id$
// Author: Rene Brun   11/02/96

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

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// An array of clone (identical) objects. Memory for the objects        //
// stored in the array is allocated only once in the lifetime of the    //
// clones array. All objects must be of the same class. For the rest    //
// this class has the same properties as TObjArray.                     //
//                                                                      //
// To reduce the very large number of new and delete calls in large     //
// loops like this (O(100000) x O(10000) times new/delete):             //
//                                                                      //
//   TObjArray a(10000);                                                //
//   while (TEvent *ev = (TEvent *)next()) {      // O(100000) events   //
//      for (int i = 0; i < ev->Ntracks; i++) {   // O(10000) tracks    //
//         a[i] = new TTrack(x,y,z,...);                                //
//         ...                                                          //
//         ...                                                          //
//      }                                                               //
//      ...                                                             //
//      a.Delete();                                                     //
//   }                                                                  //
//                                                                      //
// One better uses a TClonesArray which reduces the number of           //
// new/delete calls to only O(10000):                                   //
//                                                                      //
//   TClonesArray a("TTrack", 10000);                                   //
//   while (TEvent *ev = (TEvent *)next()) {      // O(100000) events   //
//      for (int i = 0; i < ev->Ntracks; i++) {   // O(10000) tracks    //
//         new(a[i]) TTrack(x,y,z,...);                                 //
//         ...                                                          //
//         ...                                                          //
//      }                                                               //
//      ...                                                             //
//      a.Delete(); // or a.Clear() or a.Clear("C")                     //
//   }                                                                  //
//                                                                      //
// To reduce the number of call to the constructor (especially useful   //
// if the user class requires memory allocation), the object can be     //
// added (and constructed when needed) using ConstructedAt which only   //
// calls the constructor once per slot.                                 //
//                                                                      //
//   TClonesArray a("TTrack", 10000);                                   //
//   while (TEvent *ev = (TEvent *)next()) {      // O(100000) events   //
//      for (int i = 0; i < ev->Ntracks; i++) {   // O(10000) tracks    //
//         TTrack *track = (TTrack*)a.ConstructedAt(i);                 //
//         track->Set(x,y,z,....);                                      //
//         ...                                                          //
//         ...                                                          //
//      }                                                               //
//      ...                                                             //
//      a.Clear(); // or a.Clear("C");                                  //
//   }                                                                  //
//                                                                      //
// Note: the only supported way to add objects to a TClonesArray is     //
// via the new with placement method or the ConstructedAt method.       //
// The other Add() methods ofTObjArray and its base classes are not     //
// allowed.                                                             //
//                                                                      //
// Considering that a new/delete costs about 70 mus on a 300 MHz HP,    //
// O(10^9) new/deletes will save about 19 hours.                        //
//                                                                      //
//  NOTE 1
//  ======
// C/C++ offers the possibility of allocating and deleting memory.
// Forgetting to delete allocated memory is a programming error called a
// "memory leak", i.e. the memory of your process grows and eventually
// your program crashes. Even if you *always* delete the allocated
// memory, the recovered space may not be efficiently reused. The
// process knows that there are portions of free memory, but when you
// allocate it again, a fresh piece of memory is grabbed. Your program
// is free from semantic errors, but the total memory of your process
// still grows, because your program's memory is full of "holes" which
// reduce the efficiency of memory access; this is called "memory
// fragmentation". Moreover new / delete are expensive operations in
// terms of CPU time.
//
// Without entering into technical details, TClonesArray allows you to
// "reuse" the same portion of memory for new/delete avoiding memory
// fragmentation and memory growth and improving the performance by
// orders of magnitude. Every time the memory of the TClonesArray has
// to be reused, the Clear() method is used. To provide its benefits,
// each TClonesArray must be allocated *once* per process and disposed
// of (deleted) *only when not needed any more*.
//
// So a job should see *only one* deletion for each TClonesArray,
// which should be Clear()ed during the job several times. Deleting a
// TClonesArray is a double waste. Not only you do not avoid memory
// fragmentation, but you worsen it because the TClonesArray itself
// is a rather heavy structure, and there is quite some code in the
// destructor, so you have more memory fragmentation and slower code.
//
//  NOTE 2
//  ======
//
// When investigating misuse of TClonesArray, please make sure of the following:
//
//    * Use Clear() or Clear("C") instead of Delete(). This will improve
//      program execution time.
//    * TClonesArray object classes containing pointers allocate memory.
//      To avoid causing memory leaks, special Clear("C") must be used
//      for clearing TClonesArray. When option "C" is specified, ROOT
//      automatically executes the Clear() method (by default it is
//      empty contained in TObject). This method must be overridden in
//      the relevant TClonesArray object class, implementing the reset
//      procedure for pointer objects.
//    * To reduce memory fragmentation, please make sure that the
//      TClonesArrays are not destroyed and created on every event. They
//      must only be constructed/destructed at the beginning/end of the
//      run.
//
//////////////////////////////////////////////////////////////////////////

#include <stdlib.h>
#include "TClonesArray.h"
#include "TError.h"
#include "TROOT.h"
#include "TClass.h"
#include "TObjectTable.h"


ClassImp(TClonesArray)

//______________________________________________________________________________
TClonesArray::TClonesArray() : TObjArray()
{
   // Default Constructor.

   fClass      = 0;
   fKeep       = 0;
}

//______________________________________________________________________________
TClonesArray::TClonesArray(const char *classname, Int_t s, Bool_t) : TObjArray(s)
{
   // Create an array of clone objects of classname. The class must inherit from
   // TObject. If the class defines its own operator delete(), make sure that
   // it looks like this:
   //
   //    void MyClass::operator delete(void *vp)
   //    {
   //       if ((Long_t) vp != TObject::GetDtorOnly())
   //          ::operator delete(vp);       // delete space
   //       else
   //          TObject::SetDtorOnly(0);
   //    }
   //
   // The second argument s indicates an approximate number of objects
   // that will be entered in the array. If more than s objects are entered,
   // the array will be automatically expanded.
   //
   // The third argument is not used anymore and only there for backward
   // compatibility reasons.

   fKeep = 0;
   SetClass(classname,s);
}

//______________________________________________________________________________
TClonesArray::TClonesArray(const TClass *cl, Int_t s, Bool_t) : TObjArray(s)
{
   // Create an array of clone objects of class cl. The class must inherit from
   // TObject. If the class defines an own operator delete(), make sure that
   // it looks like this:
   //
   //    void MyClass::operator delete(void *vp)
   //    {
   //       if ((Long_t) vp != TObject::GetDtorOnly())
   //          ::operator delete(vp);       // delete space
   //       else
   //          TObject::SetDtorOnly(0);
   //    }
   //
   // The second argument, s, indicates an approximate number of objects
   // that will be entered in the array. If more than s objects are entered,
   // the array will be automatically expanded.
   //
   // The third argument is not used anymore and only there for backward
   // compatibility reasons.

   fKeep = 0;
   SetClass(cl,s);
}

//______________________________________________________________________________
TClonesArray::TClonesArray(const TClonesArray& tc): TObjArray(tc)
{
   // Copy ctor.

   fKeep = new TObjArray(tc.fSize);
   fClass = tc.fClass;

   BypassStreamer(kTRUE);

   for (Int_t i = 0; i < fSize; i++) {
      if (tc.fCont[i]) fCont[i] = tc.fCont[i]->Clone();
      fKeep->fCont[i] = fCont[i];
   }
}

//______________________________________________________________________________
TClonesArray& TClonesArray::operator=(const TClonesArray& tc)
{
   // Assignment operator.

   if (this == &tc) return *this;

   if (fClass != tc.fClass) {
      Error("operator=", "cannot copy TClonesArray's when classes are different");
      return *this;
   }

   if (tc.fSize > fSize)
      Expand(TMath::Max(tc.fSize, GrowBy(fSize)));

   Int_t i;

   for (i = 0; i < fSize; i++)
      if (fKeep->fCont[i]) {
         if (TObject::GetObjectStat() && gObjectTable)
            gObjectTable->RemoveQuietly(fKeep->fCont[i]);
         ::operator delete(fKeep->fCont[i]);
         fKeep->fCont[i] = 0;
         fCont[i] = 0;
      }

   BypassStreamer(kTRUE);

   for (i = 0; i < tc.fSize; i++) {
      if (tc.fCont[i]) fKeep->fCont[i] = tc.fCont[i]->Clone();
      fCont[i] = fKeep->fCont[i];
   }

   fLast = tc.fLast;
   Changed();
   return *this;
}

//______________________________________________________________________________
TClonesArray::~TClonesArray()
{
   // Delete a clones array.

   if (fKeep) {
      for (Int_t i = 0; i < fKeep->fSize; i++) {
         TObject* p = fKeep->fCont[i];
         if (p && p->TestBit(kNotDeleted)) {
            // -- The TObject destructor has not been called.
            fClass->Destructor(p);
            fKeep->fCont[i] = 0;
         } else {
            // -- The TObject destructor was called, just free memory.
            //
            // remove any possible entries from the ObjectTable
            if (TObject::GetObjectStat() && gObjectTable) {
               gObjectTable->RemoveQuietly(p);
            }
            ::operator delete(p);
            fKeep->fCont[i] = 0;
         }
      }
   }
   SafeDelete(fKeep);

   // Protect against erroneously setting of owner bit
   SetOwner(kFALSE);
}

//______________________________________________________________________________
void TClonesArray::BypassStreamer(Bool_t bypass)
{
   // When the kBypassStreamer bit is set, the automatically
   // generated Streamer can call directly TClass::WriteBuffer.
   // Bypassing the Streamer improves the performance when writing/reading
   // the objects in the TClonesArray. However there is a drawback:
   // When a TClonesArray is written with split=0 bypassing the Streamer,
   // the StreamerInfo of the class in the array being optimized,
   // one cannot use later the TClonesArray with split>0. For example,
   // there is a problem with the following scenario:
   //  1- A class Foo has a TClonesArray of Bar objects
   //  2- The Foo object is written with split=0 to Tree T1.
   //     In this case the StreamerInfo for the class Bar is created
   //     in optimized mode in such a way that data members of the same type
   //     are written as an array improving the I/O performance.
   //  3- In a new program, T1 is read and a new Tree T2 is created
   //     with the object Foo in split>1
   //  4- When the T2 branch is created, the StreamerInfo for the class Bar
   //     is created with no optimization (mandatory for the split mode).
   //     The optimized Bar StreamerInfo is going to be used to read
   //     the TClonesArray in T1. The result will be Bar objects with
   //     data member values not in the right sequence.
   // The solution to this problem is to call BypassStreamer(kFALSE)
   // for the TClonesArray. In this case, the normal Bar::Streamer function
   // will be called. The Bar::Streamer function works OK independently
   // if the Bar StreamerInfo had been generated in optimized mode or not.

   if (bypass)
      SetBit(kBypassStreamer);
   else
      ResetBit(kBypassStreamer);
}

//______________________________________________________________________________
void TClonesArray::Compress()
{
   // Remove empty slots from array.

   Int_t j = 0, je = 0;

   TObject **tmp = new TObject* [fSize];

   for (Int_t i = 0; i < fSize; i++) {
      if (fCont[i]) {
         fCont[j] = fCont[i];
         fKeep->fCont[j] = fKeep->fCont[i];
         j++;
      } else {
         tmp[je] = fKeep->fCont[i];
         je++;
      }
   }

   fLast = j - 1;

   Int_t jf = 0;
   for ( ; j < fSize; j++) {
      fCont[j] = 0;
      fKeep->fCont[j] = tmp[jf];
      jf++;
   }

   delete [] tmp;

   R__ASSERT(je == jf);
}

//______________________________________________________________________________
TObject *TClonesArray::ConstructedAt(Int_t idx)
{
   // Get an object at index 'idx' that is guaranteed to have been constructed.
   // It might be either a freshly allocated object or one that had already been
   // allocated (and assumingly used).  In the later case, it is the callers 
   // responsability to insure that the object is returned to a known state,
   // usually by calling the Clear method on the TClonesArray.
   //
   // Tests to see if the destructor has been called on the object.  
   // If so, or if the object has never been constructed the class constructor is called using
   // New().  If not, return a pointer to the correct memory location.
   // This explicitly to deal with TObject classes that allocate memory
   // which will be reset (but not deallocated) in their Clear()
   // functions.
   
   TObject *obj = (*this)[idx];
   if ( obj && obj->TestBit(TObject::kNotDeleted) ) {
      return obj;
   }
   return (fClass) ? static_cast<TObject*>(fClass->New(obj)) : 0;
}
   
//______________________________________________________________________________
TObject *TClonesArray::ConstructedAt(Int_t idx, Option_t *clear_options)
{
   // Get an object at index 'idx' that is guaranteed to have been constructed.
   // It might be either a freshly allocated object or one that had already been
   // allocated (and assumingly used).  In the later case, the function Clear
   // will be called and passed the value of 'clear_options'
   //
   // Tests to see if the destructor has been called on the object.  
   // If so, or if the object has never been constructed the class constructor is called using
   // New().  If not, return a pointer to the correct memory location.
   // This explicitly to deal with TObject classes that allocate memory
   // which will be reset (but not deallocated) in their Clear()
   // functions.
   
   TObject *obj = (*this)[idx];
   if ( obj && obj->TestBit(TObject::kNotDeleted) ) {
      obj->Clear(clear_options);
      return obj;
   }
   return (fClass) ? static_cast<TObject*>(fClass->New(obj)) : 0;
}

//______________________________________________________________________________
void TClonesArray::Clear(Option_t *option)
{
   // Clear the clones array. Only use this routine when your objects don't
   // allocate memory since it will not call the object dtors.
   // However, if the class in the TClonesArray implements the function
   // Clear(Option_t *option) and if option = "C" the function Clear()
   // is called for all objects in the array. In the function Clear(), one
   // can delete objects or dynamic arrays allocated in the class.
   // This procedure is much faster than calling TClonesArray::Delete().
   // When the option starts with "C+", eg "C+xyz" the objects in the array
   // are in turn cleared with the option "xyz"

   if (option && option[0] == 'C') {
      const char *cplus = strstr(option,"+");
      if (cplus) {
         cplus = cplus + 1;
      } else {
         cplus = "";
      }
      Int_t n = GetEntriesFast();
      for (Int_t i = 0; i < n; i++) {
         TObject *obj = UncheckedAt(i);
         if (obj) {
            obj->Clear(cplus);
            obj->ResetBit( kHasUUID ); 
            obj->ResetBit( kIsReferenced ); 
            obj->SetUniqueID( 0 );
         }
      }
   }

   // Protect against erroneously setting of owner bit
   SetOwner(kFALSE);

   TObjArray::Clear();
}

//______________________________________________________________________________
void TClonesArray::Delete(Option_t *)
{
   // Clear the clones array. Use this routine when your objects allocate
   // memory (e.g. objects inheriting from TNamed or containing TStrings
   // allocate memory). If not you better use Clear() since if is faster.

   if ( fClass->TestBit(TClass::kIsEmulation) ) {
      // In case of emulated class, we can not use the delete operator
      // directly, it would use the wrong destructor.
      for (Int_t i = 0; i < fSize; i++) {
         if (fCont[i] && fCont[i]->TestBit(kNotDeleted)) {
            fClass->Destructor(fCont[i],kTRUE);
         }
      }
   } else {
      Long_t dtoronly = TObject::GetDtorOnly();
      for (Int_t i = 0; i < fSize; i++) {
         if (fCont[i] && fCont[i]->TestBit(kNotDeleted)) {
            // Tell custom operator delete() not to delete space when
            // object fCont[i] is deleted. Only destructors are called
            // for this object.
            TObject::SetDtorOnly(fCont[i]);
            delete fCont[i];
         }
      }
      // Restore the state.
      TObject::SetDtorOnly((void*)dtoronly);
   }

   // Protect against erroneously setting of owner bit.
   SetOwner(kFALSE);

   TObjArray::Clear();
}

//______________________________________________________________________________
void TClonesArray::Expand(Int_t newSize)
{
   // Expand or shrink the array to newSize elements.

   if (newSize < 0) {
      Error ("Expand", "newSize must be positive (%d)", newSize);
      return;
   }
   if (newSize == fSize)
      return;
   if (newSize < fSize) {
      // release allocated space in fKeep and set to 0 so
      // Expand() will shrink correctly
      for (int i = newSize; i < fSize; i++)
         if (fKeep->fCont[i]) {
            if (TObject::GetObjectStat() && gObjectTable)
               gObjectTable->RemoveQuietly(fKeep->fCont[i]);
            ::operator delete(fKeep->fCont[i]);
            fKeep->fCont[i] = 0;
         }
   }

   TObjArray::Expand(newSize);
   fKeep->Expand(newSize);
}

//______________________________________________________________________________
void TClonesArray::ExpandCreate(Int_t n)
{
   // Expand or shrink the array to n elements and create the clone
   // objects by calling their default ctor. If n is less than the current size
   // the array is shrunk and the allocated space is freed.
   // This routine is typically used to create a clonesarray into which
   // one can directly copy object data without going via the
   // "new (arr[i]) MyObj()" (i.e. the vtbl is already set correctly).

   if (n < 0) {
      Error("ExpandCreate", "n must be positive (%d)", n);
      return ;
   }
   if (n > fSize)
      Expand(TMath::Max(n, GrowBy(fSize)));

   Int_t i;
   for (i = 0; i < n; i++) {
      if (!fKeep->fCont[i]) {
         fKeep->fCont[i] = (TObject*)fClass->New();
      } else if (!fKeep->fCont[i]->TestBit(kNotDeleted)) {
         // The object has been deleted (or never initialized)
         fClass->New(fKeep->fCont[i]);
      }
      fCont[i] = fKeep->fCont[i];
   }

   for (i = n; i < fSize; i++)
      if (fKeep->fCont[i]) {
         if (TObject::GetObjectStat() && gObjectTable)
            gObjectTable->RemoveQuietly(fKeep->fCont[i]);
         ::operator delete(fKeep->fCont[i]);
         fKeep->fCont[i] = 0;
         fCont[i] = 0;
      }

   fLast = n - 1;
   Changed();
}

//______________________________________________________________________________
void TClonesArray::ExpandCreateFast(Int_t n)
{
   // Expand or shrink the array to n elements and create the clone
   // objects by calling their default ctor. If n is less than the current size
   // the array is shrinked but the allocated space is _not_ freed.
   // This routine is typically used to create a clonesarray into which
   // one can directly copy object data without going via the
   // "new (arr[i]) MyObj()" (i.e. the vtbl is already set correctly).
   // This is a simplified version of ExpandCreate used in the TTree mechanism.

   Int_t oldSize = fKeep->GetSize();
   if (n > fSize)
      Expand(TMath::Max(n, GrowBy(fSize)));

   Int_t i;
   for (i = 0; i < n; i++) {
      if (i >= oldSize || !fKeep->fCont[i]) {
         fKeep->fCont[i] = (TObject*)fClass->New();
      } else if (!fKeep->fCont[i]->TestBit(kNotDeleted)) {
         // The object has been deleted (or never initialized)
         fClass->New(fKeep->fCont[i]);
      }
      fCont[i] = fKeep->fCont[i];
   }
   if (fLast >= n) {
      memset(fCont + n, 0, (fLast - n + 1) * sizeof(TObject*));
   }
   fLast = n - 1;
   Changed();
}

//______________________________________________________________________________
TObject *TClonesArray::RemoveAt(Int_t idx)
{
   // Remove object at index idx.

   if (!BoundsOk("RemoveAt", idx)) return 0;

   int i = idx-fLowerBound;

   if (fCont[i] && fCont[i]->TestBit(kNotDeleted)) {
      // Tell custom operator delete() not to delete space when
      // object fCont[i] is deleted. Only destructors are called
      // for this object.
      Long_t dtoronly = TObject::GetDtorOnly();
      TObject::SetDtorOnly(fCont[i]);
      delete fCont[i];
      TObject::SetDtorOnly((void*)dtoronly);
   }

   if (fCont[i]) {
      fCont[i] = 0;
      // recalculate array size
      if (i == fLast)
         do { fLast--; } while (fLast >= 0 && fCont[fLast] == 0);
      Changed();
   }

   return 0;
}

//______________________________________________________________________________
TObject *TClonesArray::Remove(TObject *obj)
{
   // Remove object from array.

   if (!obj) return 0;

   Int_t i = IndexOf(obj) - fLowerBound;

   if (i == -1) return 0;

   if (fCont[i] && fCont[i]->TestBit(kNotDeleted)) {
      // Tell custom operator delete() not to delete space when
      // object fCont[i] is deleted. Only destructors are called
      // for this object.
      Long_t dtoronly = TObject::GetDtorOnly();
      TObject::SetDtorOnly(fCont[i]);
      delete fCont[i];
      TObject::SetDtorOnly((void*)dtoronly);
   }

   fCont[i] = 0;
   // recalculate array size
   if (i == fLast)
      do { fLast--; } while (fLast >= 0 && fCont[fLast] == 0);
   Changed();
   return obj;
}

//______________________________________________________________________________
void TClonesArray::RemoveRange(Int_t idx1, Int_t idx2)
{
   // Remove objects from index idx1 to idx2 included.

   if (!BoundsOk("RemoveRange", idx1)) return;
   if (!BoundsOk("RemoveRange", idx2)) return;

   Long_t dtoronly = TObject::GetDtorOnly();

   idx1 -= fLowerBound;
   idx2 -= fLowerBound;

   Bool_t change = kFALSE;
   for (TObject **obj=fCont+idx1; obj<=fCont+idx2; obj++) {
      if (!*obj) continue;
      if ((*obj)->TestBit(kNotDeleted)) {
         // Tell custom operator delete() not to delete space when
         // object fCont[i] is deleted. Only destructors are called
         // for this object.
         TObject::SetDtorOnly(*obj);
         delete *obj;
      }
      *obj = 0;
      change = kTRUE;
   }

   TObject::SetDtorOnly((void*)dtoronly);

   // recalculate array size
   if (change) Changed();
   if (idx1 < fLast || fLast > idx2) return;
   do { fLast--; } while (fLast >= 0 && fCont[fLast] == 0);
}

//______________________________________________________________________________
void TClonesArray::SetClass(const TClass *cl, Int_t s)
{
   // Create an array of clone objects of class cl. The class must inherit from
   // TObject. If the class defines an own operator delete(), make sure that
   // it looks like this:
   //
   //    void MyClass::operator delete(void *vp)
   //    {
   //       if ((Long_t) vp != TObject::GetDtorOnly())
   //          ::operator delete(vp);       // delete space
   //       else
   //          TObject::SetDtorOnly(0);
   //    }
   //
   // The second argument s indicates an approximate number of objects
   // that will be entered in the array. If more than s objects are entered,
   // the array will be automatically expanded.
   //
   // NB: This function should not be called in the TClonesArray is already
   //     initialized with a class.

   if (fKeep) {
      Error("SetClass", "TClonesArray already initialized with another class");
      return;
   }
   fClass = (TClass*)cl;
   if (!fClass) {
      MakeZombie();
      Error("SetClass", "called with a null pointer");
      return;
   }
   const char *classname = fClass->GetName();
   if (!fClass->InheritsFrom(TObject::Class())) {
      MakeZombie();
      Error("SetClass", "%s does not inherit from TObject", classname);
      return;
   }
   if (fClass->GetBaseClassOffset(TObject::Class())!=0) {
      MakeZombie();
      Error("SetClass", "%s must inherit from TObject as the left most base class.", classname);
      return;      
   }
   Int_t nch = strlen(classname)+2;
   char *name = new char[nch];
   snprintf(name,nch, "%ss", classname);
   SetName(name);
   delete [] name;

   fKeep = new TObjArray(s);

   BypassStreamer(kTRUE);
}

//______________________________________________________________________________
void TClonesArray::SetClass(const char *classname, Int_t s)
{
   //see TClonesArray::SetClass(const TClass*)

   SetClass(TClass::GetClass(classname),s);
}


//______________________________________________________________________________
void TClonesArray::SetOwner(Bool_t /* enable */)
{
   // A TClonesArray is always the owner of the object it contains.
   // However the collection its inherits from (TObjArray) does not.
   // Hence this member function needs to be a nop for TClonesArray.

   // Nothing to be done.
}

//______________________________________________________________________________
void TClonesArray::Sort(Int_t upto)
{
   // If objects in array are sortable (i.e. IsSortable() returns true
   // for all objects) then sort array.

   Int_t nentries = GetAbsLast()+1;
   if (nentries <= 0 || fSorted) return;
   for (Int_t i = 0; i < fSize; i++)
      if (fCont[i]) {
         if (!fCont[i]->IsSortable()) {
            Error("Sort", "objects in array are not sortable");
            return;
         }
      }

   QSort(fCont, fKeep->fCont, 0, TMath::Min(nentries, upto-fLowerBound));

   fLast   = -2;
   fSorted = kTRUE;
}

//_______________________________________________________________________
void TClonesArray::Streamer(TBuffer &b)
{
   // Write all objects in array to the I/O buffer. ATTENTION: empty slots
   // are also stored (using one byte per slot). If you don't want this
   // use a TOrdCollection or TList.

   // Important Note: if you modify this function, remember to also modify
   // TConvertClonesArrayToProxy accordingly

   Int_t   nobjects;
   char    nch;
   TString s, classv;
   UInt_t R__s, R__c;

   if (b.IsReading()) {
      Version_t v = b.ReadVersion(&R__s, &R__c);
      if (v == 3) {
         const Int_t kOldBypassStreamer = BIT(14);
         if (TestBit(kOldBypassStreamer)) BypassStreamer();
      }
      if (v > 2)
         TObject::Streamer(b);
      if (v > 1)
         fName.Streamer(b);
      s.Streamer(b);
      classv = s;
      Int_t clv = 0;
      Ssiz_t pos = s.Index(";");
      if (pos != kNPOS) {
         classv = s(0, pos);
         s = s(pos+1, s.Length()-pos-1);
         clv = s.Atoi();
      }
      TClass *cl = TClass::GetClass(classv);
      if (!cl) {
         printf("TClonesArray::Streamer expecting class %s\n", classv.Data());
         b.CheckByteCount(R__s, R__c,TClonesArray::IsA());
         return;
      }

      b >> nobjects;
      if (nobjects < 0)
         nobjects = -nobjects;  // still there for backward compatibility
      b >> fLowerBound;
      if (fClass == 0 && fKeep == 0) {
         fClass = cl;
         fKeep  = new TObjArray(fSize);
         Expand(nobjects);
      }
      if (cl != fClass) {
         fClass = cl;
         //this case may happen when switching from an emulated class to the real class
         //may not be an error. fClass may point to a deleted object
         //Error("Streamer", "expecting objects of type %s, finding objects"
         //   " of type %s", fClass->GetName(), cl->GetName());
         //return;
      }

      // make sure there are enough slots in the fKeep array
      if (fKeep->GetSize() < nobjects)
         Expand(nobjects);

      //reset fLast. nobjects may be 0
      Int_t oldLast = fLast;
      fLast = nobjects-1;

      //TStreamerInfo *sinfo = fClass->GetStreamerInfo(clv);
      if (CanBypassStreamer() && !b.TestBit(TBuffer::kCannotHandleMemberWiseStreaming)) {
         for (Int_t i = 0; i < nobjects; i++) {
            if (!fKeep->fCont[i]) {
               fKeep->fCont[i] = (TObject*)fClass->New();
            } else if (!fKeep->fCont[i]->TestBit(kNotDeleted)) {
               // The object has been deleted (or never initialized)
               fClass->New(fKeep->fCont[i]);
            }

            fCont[i] = fKeep->fCont[i];
         }
         //sinfo->ReadBufferClones(b,this,nobjects,-1,0);
         b.ReadClones(this,nobjects,clv);

      } else {
         for (Int_t i = 0; i < nobjects; i++) {
            b >> nch;
            if (nch) {
               if (!fKeep->fCont[i])
                  fKeep->fCont[i] = (TObject*)fClass->New();
               else if (!fKeep->fCont[i]->TestBit(kNotDeleted)) {
                  // The object has been deleted (or never initialized)
                  fClass->New(fKeep->fCont[i]);
               }

               fCont[i] = fKeep->fCont[i];
               b.StreamObject(fKeep->fCont[i]);
            }
         }
      }
      for (Int_t i = TMath::Max(nobjects,0); i < oldLast+1; ++i) fCont[i] = 0;
      Changed();
      b.CheckByteCount(R__s, R__c,TClonesArray::IsA());
   } else {
      //Make sure TStreamerInfo is not optimized, otherwise it will not be
      //possible to support schema evolution in read mode.
      //In case the StreamerInfo has already been computed and optimized,
      //one must disable the option BypassStreamer
      b.ForceWriteInfoClones(this);

      // make sure the status of bypass streamer is part of the buffer
      // (bits in TObject), so that when reading the object the right
      // mode is used, independent of the method (e.g. written via
      // TMessage, received and stored to a file and then later read via
      // TBufferFile)
      Bool_t bypass = kFALSE;
      if (b.TestBit(TBuffer::kCannotHandleMemberWiseStreaming)) {
         bypass = CanBypassStreamer();
         BypassStreamer(kFALSE);
      }

      R__c = b.WriteVersion(TClonesArray::IsA(), kTRUE);
      TObject::Streamer(b);
      fName.Streamer(b);
      s.Form("%s;%d", fClass->GetName(), fClass->GetClassVersion());
      s.Streamer(b);
      nobjects = GetEntriesFast();
      b << nobjects;
      b << fLowerBound;
      if (CanBypassStreamer()) {
         b.WriteClones(this,nobjects);
      } else {
         for (Int_t i = 0; i < nobjects; i++) {
            if (!fCont[i]) {
               nch = 0;
               b << nch;
            } else {
               nch = 1;
               b << nch;
               b.StreamObject(fCont[i]);
            }
         }
      }
      b.SetByteCount(R__c, kTRUE);

      if (bypass)
         BypassStreamer();
   }
}

//______________________________________________________________________________
TObject *&TClonesArray::operator[](Int_t idx)
{
   // Return pointer to reserved area in which a new object of clones
   // class can be constructed. This operator should not be used for
   // lefthand side assignments, like a[2] = xxx. Only like,
   // new (a[2]) myClass, or xxx = a[2]. Of course right hand side usage
   // is only legal after the object has been constructed via the
   // new operator or via the New() method. To remove elements from
   // the clones array use Remove() or RemoveAt().

   if (idx < 0) {
      Error("operator[]", "out of bounds at %d in %lx", idx, (Long_t)this);
      return fCont[0];
   }
   if (!fClass) {
      Error("operator[]", "invalid class specified in TClonesArray ctor");
      return fCont[0];
   }
   if (idx >= fSize)
      Expand(TMath::Max(idx+1, GrowBy(fSize)));

   if (!fKeep->fCont[idx]) {
      fKeep->fCont[idx] = (TObject*) TStorage::ObjectAlloc(fClass->Size());
      // Reset the bit so that:
      //    obj = myClonesArray[i];
      //    obj->TestBit(TObject::kNotDeleted)
      // will behave correctly.
      // TObject::kNotDeleted is one of the higher bit that is not settable via the public
      // interface. But luckily we are its friend.
      fKeep->fCont[idx]->fBits &= ~kNotDeleted;
   }
   fCont[idx] = fKeep->fCont[idx];

   fLast = TMath::Max(idx, GetAbsLast());
   Changed();

   return fCont[idx];
}

//______________________________________________________________________________
TObject *TClonesArray::operator[](Int_t idx) const
{
   // Return the object at position idx. Returns 0 if idx is out of bounds.

   if (idx < 0 || idx >= fSize) {
      Error("operator[]", "out of bounds at %d in %lx", idx, (Long_t)this);
      return 0;
   }

   return fCont[idx];
}

//______________________________________________________________________________
TObject *TClonesArray::New(Int_t idx)
{
   // Create an object of type fClass with the default ctor at the specified
   // index. Returns 0 in case of error.

   if (idx < 0) {
      Error("New", "out of bounds at %d in %lx", idx, (Long_t)this);
      return 0;
   }
   if (!fClass) {
      Error("New", "invalid class specified in TClonesArray ctor");
      return 0;
   }

   return (TObject *)fClass->New(operator[](idx));
}

//______________________________________________________________________________
//
// The following functions are utilities implemented by Jason Detwiler
// (jadetwiler@lbl.gov)
//
//______________________________________________________________________________
void TClonesArray::AbsorbObjects(TClonesArray *tc)
{
   // Directly move the object pointers from tc without cloning (copying).
   // This TClonesArray takes over ownership of all of tc's object
   // pointers. The tc array is left empty upon return.

   // tests
   if (tc == 0 || tc == this || tc->GetEntriesFast() == 0) return;
   if (fClass != tc->fClass) {
      Error("AbsorbObjects", "cannot absorb objects when classes are different");
      return;
   }

   // cache the sorted status
   Bool_t wasSorted = IsSorted() && tc->IsSorted() &&
                      (Last() == 0 || Last()->Compare(tc->First()) == -1);

   // expand this
   Int_t oldSize = GetEntriesFast();
   Int_t newSize = oldSize + tc->GetEntriesFast();
   if(newSize > fSize)
      Expand(newSize);

   // move
   for (Int_t i = 0; i < tc->GetEntriesFast(); ++i) {
      fCont[oldSize+i] = tc->fCont[i];
      (*fKeep)[oldSize+i] = (*(tc->fKeep))[i];
      tc->fCont[i] = 0;
      (*(tc->fKeep))[i] = 0;
   }

   // cleanup
   fLast = newSize-1;
   tc->fLast = -1;
   if (!wasSorted)
      Changed();
}

//______________________________________________________________________________
void TClonesArray::AbsorbObjects(TClonesArray *tc, Int_t idx1, Int_t idx2)
{
   // Directly move the range of object pointers from tc without cloning
   // (copying).
   // This TClonesArray takes over ownership of all of tc's object pointers
   // from idx1 to idx2. The tc array is re-arranged by return.

   // tests
   if (tc == 0 || tc == this || tc->GetEntriesFast() == 0) return;
   if (fClass != tc->fClass) {
      Error("AbsorbObjects", "cannot absorb objects when classes are different");
      return;
   }

   if (idx1 > idx2) {
      Error("AbsorbObjects", "range is not valid: idx1>idx2");
      return;
   }

   // cache the sorted status
   Bool_t wasSorted = IsSorted() && tc->IsSorted() &&
                      (Last() == 0 || Last()->Compare(tc->First()) == -1);

   // expand this
   Int_t oldSize = GetEntriesFast();
   Int_t newSize = oldSize + (idx2-idx1+1);
   if(newSize > fSize)
      Expand(newSize);

   // move
   for (Int_t i = idx1; i <= idx2; i++) {
      Int_t newindex = oldSize+i -idx1; 
      fCont[newindex] = tc->fCont[i];
      ::operator delete(fKeep->fCont[newindex]);
      (*fKeep)[newindex] = (*(tc->fKeep))[i];
      tc->fCont[i] = 0;
      (*(tc->fKeep))[i] = 0;
   }

   // cleanup
   for (Int_t i = idx2+1; i < tc->GetEntriesFast(); i++) {
      tc->fCont[i-(idx2-idx1+1)] = tc->fCont[i];
      (*(tc->fKeep))[i-(idx2-idx1+1)] = (*(tc->fKeep))[i];
      tc->fCont[i] = 0;
      (*(tc->fKeep))[i] = 0;
   }
   tc->fLast = tc->GetEntriesFast() - 2 - (idx2 - idx1);
   fLast = newSize-1;
   if (!wasSorted)
      Changed();
}

//______________________________________________________________________________
void TClonesArray::MultiSort(Int_t nTCs, TClonesArray** tcs, Int_t upto)
{
   // Sort multiple TClonesArrays simultaneously with this array.
   // If objects in array are sortable (i.e. IsSortable() returns true
   // for all objects) then sort array.

   Int_t nentries = GetAbsLast()+1;
   if (nentries <= 1 || fSorted) return;
   Bool_t sortedCheck = kTRUE;
   for (Int_t i = 0; i < fSize; i++) {
      if (fCont[i]) {
         if (!fCont[i]->IsSortable()) {
            Error("MultiSort", "objects in array are not sortable");
            return;
         }
      }
      if (sortedCheck && i > 1) {
         if (ObjCompare(fCont[i], fCont[i-1]) < 0) sortedCheck = kFALSE;
      }
   }
   if (sortedCheck) {
      fSorted = kTRUE;
      return;
   }

   for (int i = 0; i < nTCs; i++) {
      if (tcs[i] == this) {
         Error("MultiSort", "tcs[%d] = \"this\"", i);
         return;
      }
      if (tcs[i]->GetEntriesFast() != GetEntriesFast()) {
         Error("MultiSort", "tcs[%d] has length %d != length of this (%d)",
               i, tcs[i]->GetEntriesFast(), this->GetEntriesFast());
         return;
      }
   }

   int nBs = nTCs*2+1;
   TObject*** b = new TObject**[nBs];
   for (int i = 0; i < nTCs; i++) {
      b[2*i]   = tcs[i]->fCont;
      b[2*i+1] = tcs[i]->fKeep->fCont;
   }
   b[nBs-1] = fKeep->fCont;
   QSort(fCont, nBs, b, 0, TMath::Min(nentries, upto-fLowerBound));
   delete [] b;

   fLast = -2;
   fSorted = kTRUE;
}
 TClonesArray.cxx:1
 TClonesArray.cxx:2
 TClonesArray.cxx:3
 TClonesArray.cxx:4
 TClonesArray.cxx:5
 TClonesArray.cxx:6
 TClonesArray.cxx:7
 TClonesArray.cxx:8
 TClonesArray.cxx:9
 TClonesArray.cxx:10
 TClonesArray.cxx:11
 TClonesArray.cxx:12
 TClonesArray.cxx:13
 TClonesArray.cxx:14
 TClonesArray.cxx:15
 TClonesArray.cxx:16
 TClonesArray.cxx:17
 TClonesArray.cxx:18
 TClonesArray.cxx:19
 TClonesArray.cxx:20
 TClonesArray.cxx:21
 TClonesArray.cxx:22
 TClonesArray.cxx:23
 TClonesArray.cxx:24
 TClonesArray.cxx:25
 TClonesArray.cxx:26
 TClonesArray.cxx:27
 TClonesArray.cxx:28
 TClonesArray.cxx:29
 TClonesArray.cxx:30
 TClonesArray.cxx:31
 TClonesArray.cxx:32
 TClonesArray.cxx:33
 TClonesArray.cxx:34
 TClonesArray.cxx:35
 TClonesArray.cxx:36
 TClonesArray.cxx:37
 TClonesArray.cxx:38
 TClonesArray.cxx:39
 TClonesArray.cxx:40
 TClonesArray.cxx:41
 TClonesArray.cxx:42
 TClonesArray.cxx:43
 TClonesArray.cxx:44
 TClonesArray.cxx:45
 TClonesArray.cxx:46
 TClonesArray.cxx:47
 TClonesArray.cxx:48
 TClonesArray.cxx:49
 TClonesArray.cxx:50
 TClonesArray.cxx:51
 TClonesArray.cxx:52
 TClonesArray.cxx:53
 TClonesArray.cxx:54
 TClonesArray.cxx:55
 TClonesArray.cxx:56
 TClonesArray.cxx:57
 TClonesArray.cxx:58
 TClonesArray.cxx:59
 TClonesArray.cxx:60
 TClonesArray.cxx:61
 TClonesArray.cxx:62
 TClonesArray.cxx:63
 TClonesArray.cxx:64
 TClonesArray.cxx:65
 TClonesArray.cxx:66
 TClonesArray.cxx:67
 TClonesArray.cxx:68
 TClonesArray.cxx:69
 TClonesArray.cxx:70
 TClonesArray.cxx:71
 TClonesArray.cxx:72
 TClonesArray.cxx:73
 TClonesArray.cxx:74
 TClonesArray.cxx:75
 TClonesArray.cxx:76
 TClonesArray.cxx:77
 TClonesArray.cxx:78
 TClonesArray.cxx:79
 TClonesArray.cxx:80
 TClonesArray.cxx:81
 TClonesArray.cxx:82
 TClonesArray.cxx:83
 TClonesArray.cxx:84
 TClonesArray.cxx:85
 TClonesArray.cxx:86
 TClonesArray.cxx:87
 TClonesArray.cxx:88
 TClonesArray.cxx:89
 TClonesArray.cxx:90
 TClonesArray.cxx:91
 TClonesArray.cxx:92
 TClonesArray.cxx:93
 TClonesArray.cxx:94
 TClonesArray.cxx:95
 TClonesArray.cxx:96
 TClonesArray.cxx:97
 TClonesArray.cxx:98
 TClonesArray.cxx:99
 TClonesArray.cxx:100
 TClonesArray.cxx:101
 TClonesArray.cxx:102
 TClonesArray.cxx:103
 TClonesArray.cxx:104
 TClonesArray.cxx:105
 TClonesArray.cxx:106
 TClonesArray.cxx:107
 TClonesArray.cxx:108
 TClonesArray.cxx:109
 TClonesArray.cxx:110
 TClonesArray.cxx:111
 TClonesArray.cxx:112
 TClonesArray.cxx:113
 TClonesArray.cxx:114
 TClonesArray.cxx:115
 TClonesArray.cxx:116
 TClonesArray.cxx:117
 TClonesArray.cxx:118
 TClonesArray.cxx:119
 TClonesArray.cxx:120
 TClonesArray.cxx:121
 TClonesArray.cxx:122
 TClonesArray.cxx:123
 TClonesArray.cxx:124
 TClonesArray.cxx:125
 TClonesArray.cxx:126
 TClonesArray.cxx:127
 TClonesArray.cxx:128
 TClonesArray.cxx:129
 TClonesArray.cxx:130
 TClonesArray.cxx:131
 TClonesArray.cxx:132
 TClonesArray.cxx:133
 TClonesArray.cxx:134
 TClonesArray.cxx:135
 TClonesArray.cxx:136
 TClonesArray.cxx:137
 TClonesArray.cxx:138
 TClonesArray.cxx:139
 TClonesArray.cxx:140
 TClonesArray.cxx:141
 TClonesArray.cxx:142
 TClonesArray.cxx:143
 TClonesArray.cxx:144
 TClonesArray.cxx:145
 TClonesArray.cxx:146
 TClonesArray.cxx:147
 TClonesArray.cxx:148
 TClonesArray.cxx:149
 TClonesArray.cxx:150
 TClonesArray.cxx:151
 TClonesArray.cxx:152
 TClonesArray.cxx:153
 TClonesArray.cxx:154
 TClonesArray.cxx:155
 TClonesArray.cxx:156
 TClonesArray.cxx:157
 TClonesArray.cxx:158
 TClonesArray.cxx:159
 TClonesArray.cxx:160
 TClonesArray.cxx:161
 TClonesArray.cxx:162
 TClonesArray.cxx:163
 TClonesArray.cxx:164
 TClonesArray.cxx:165
 TClonesArray.cxx:166
 TClonesArray.cxx:167
 TClonesArray.cxx:168
 TClonesArray.cxx:169
 TClonesArray.cxx:170
 TClonesArray.cxx:171
 TClonesArray.cxx:172
 TClonesArray.cxx:173
 TClonesArray.cxx:174
 TClonesArray.cxx:175
 TClonesArray.cxx:176
 TClonesArray.cxx:177
 TClonesArray.cxx:178
 TClonesArray.cxx:179
 TClonesArray.cxx:180
 TClonesArray.cxx:181
 TClonesArray.cxx:182
 TClonesArray.cxx:183
 TClonesArray.cxx:184
 TClonesArray.cxx:185
 TClonesArray.cxx:186
 TClonesArray.cxx:187
 TClonesArray.cxx:188
 TClonesArray.cxx:189
 TClonesArray.cxx:190
 TClonesArray.cxx:191
 TClonesArray.cxx:192
 TClonesArray.cxx:193
 TClonesArray.cxx:194
 TClonesArray.cxx:195
 TClonesArray.cxx:196
 TClonesArray.cxx:197
 TClonesArray.cxx:198
 TClonesArray.cxx:199
 TClonesArray.cxx:200
 TClonesArray.cxx:201
 TClonesArray.cxx:202
 TClonesArray.cxx:203
 TClonesArray.cxx:204
 TClonesArray.cxx:205
 TClonesArray.cxx:206
 TClonesArray.cxx:207
 TClonesArray.cxx:208
 TClonesArray.cxx:209
 TClonesArray.cxx:210
 TClonesArray.cxx:211
 TClonesArray.cxx:212
 TClonesArray.cxx:213
 TClonesArray.cxx:214
 TClonesArray.cxx:215
 TClonesArray.cxx:216
 TClonesArray.cxx:217
 TClonesArray.cxx:218
 TClonesArray.cxx:219
 TClonesArray.cxx:220
 TClonesArray.cxx:221
 TClonesArray.cxx:222
 TClonesArray.cxx:223
 TClonesArray.cxx:224
 TClonesArray.cxx:225
 TClonesArray.cxx:226
 TClonesArray.cxx:227
 TClonesArray.cxx:228
 TClonesArray.cxx:229
 TClonesArray.cxx:230
 TClonesArray.cxx:231
 TClonesArray.cxx:232
 TClonesArray.cxx:233
 TClonesArray.cxx:234
 TClonesArray.cxx:235
 TClonesArray.cxx:236
 TClonesArray.cxx:237
 TClonesArray.cxx:238
 TClonesArray.cxx:239
 TClonesArray.cxx:240
 TClonesArray.cxx:241
 TClonesArray.cxx:242
 TClonesArray.cxx:243
 TClonesArray.cxx:244
 TClonesArray.cxx:245
 TClonesArray.cxx:246
 TClonesArray.cxx:247
 TClonesArray.cxx:248
 TClonesArray.cxx:249
 TClonesArray.cxx:250
 TClonesArray.cxx:251
 TClonesArray.cxx:252
 TClonesArray.cxx:253
 TClonesArray.cxx:254
 TClonesArray.cxx:255
 TClonesArray.cxx:256
 TClonesArray.cxx:257
 TClonesArray.cxx:258
 TClonesArray.cxx:259
 TClonesArray.cxx:260
 TClonesArray.cxx:261
 TClonesArray.cxx:262
 TClonesArray.cxx:263
 TClonesArray.cxx:264
 TClonesArray.cxx:265
 TClonesArray.cxx:266
 TClonesArray.cxx:267
 TClonesArray.cxx:268
 TClonesArray.cxx:269
 TClonesArray.cxx:270
 TClonesArray.cxx:271
 TClonesArray.cxx:272
 TClonesArray.cxx:273
 TClonesArray.cxx:274
 TClonesArray.cxx:275
 TClonesArray.cxx:276
 TClonesArray.cxx:277
 TClonesArray.cxx:278
 TClonesArray.cxx:279
 TClonesArray.cxx:280
 TClonesArray.cxx:281
 TClonesArray.cxx:282
 TClonesArray.cxx:283
 TClonesArray.cxx:284
 TClonesArray.cxx:285
 TClonesArray.cxx:286
 TClonesArray.cxx:287
 TClonesArray.cxx:288
 TClonesArray.cxx:289
 TClonesArray.cxx:290
 TClonesArray.cxx:291
 TClonesArray.cxx:292
 TClonesArray.cxx:293
 TClonesArray.cxx:294
 TClonesArray.cxx:295
 TClonesArray.cxx:296
 TClonesArray.cxx:297
 TClonesArray.cxx:298
 TClonesArray.cxx:299
 TClonesArray.cxx:300
 TClonesArray.cxx:301
 TClonesArray.cxx:302
 TClonesArray.cxx:303
 TClonesArray.cxx:304
 TClonesArray.cxx:305
 TClonesArray.cxx:306
 TClonesArray.cxx:307
 TClonesArray.cxx:308
 TClonesArray.cxx:309
 TClonesArray.cxx:310
 TClonesArray.cxx:311
 TClonesArray.cxx:312
 TClonesArray.cxx:313
 TClonesArray.cxx:314
 TClonesArray.cxx:315
 TClonesArray.cxx:316
 TClonesArray.cxx:317
 TClonesArray.cxx:318
 TClonesArray.cxx:319
 TClonesArray.cxx:320
 TClonesArray.cxx:321
 TClonesArray.cxx:322
 TClonesArray.cxx:323
 TClonesArray.cxx:324
 TClonesArray.cxx:325
 TClonesArray.cxx:326
 TClonesArray.cxx:327
 TClonesArray.cxx:328
 TClonesArray.cxx:329
 TClonesArray.cxx:330
 TClonesArray.cxx:331
 TClonesArray.cxx:332
 TClonesArray.cxx:333
 TClonesArray.cxx:334
 TClonesArray.cxx:335
 TClonesArray.cxx:336
 TClonesArray.cxx:337
 TClonesArray.cxx:338
 TClonesArray.cxx:339
 TClonesArray.cxx:340
 TClonesArray.cxx:341
 TClonesArray.cxx:342
 TClonesArray.cxx:343
 TClonesArray.cxx:344
 TClonesArray.cxx:345
 TClonesArray.cxx:346
 TClonesArray.cxx:347
 TClonesArray.cxx:348
 TClonesArray.cxx:349
 TClonesArray.cxx:350
 TClonesArray.cxx:351
 TClonesArray.cxx:352
 TClonesArray.cxx:353
 TClonesArray.cxx:354
 TClonesArray.cxx:355
 TClonesArray.cxx:356
 TClonesArray.cxx:357
 TClonesArray.cxx:358
 TClonesArray.cxx:359
 TClonesArray.cxx:360
 TClonesArray.cxx:361
 TClonesArray.cxx:362
 TClonesArray.cxx:363
 TClonesArray.cxx:364
 TClonesArray.cxx:365
 TClonesArray.cxx:366
 TClonesArray.cxx:367
 TClonesArray.cxx:368
 TClonesArray.cxx:369
 TClonesArray.cxx:370
 TClonesArray.cxx:371
 TClonesArray.cxx:372
 TClonesArray.cxx:373
 TClonesArray.cxx:374
 TClonesArray.cxx:375
 TClonesArray.cxx:376
 TClonesArray.cxx:377
 TClonesArray.cxx:378
 TClonesArray.cxx:379
 TClonesArray.cxx:380
 TClonesArray.cxx:381
 TClonesArray.cxx:382
 TClonesArray.cxx:383
 TClonesArray.cxx:384
 TClonesArray.cxx:385
 TClonesArray.cxx:386
 TClonesArray.cxx:387
 TClonesArray.cxx:388
 TClonesArray.cxx:389
 TClonesArray.cxx:390
 TClonesArray.cxx:391
 TClonesArray.cxx:392
 TClonesArray.cxx:393
 TClonesArray.cxx:394
 TClonesArray.cxx:395
 TClonesArray.cxx:396
 TClonesArray.cxx:397
 TClonesArray.cxx:398
 TClonesArray.cxx:399
 TClonesArray.cxx:400
 TClonesArray.cxx:401
 TClonesArray.cxx:402
 TClonesArray.cxx:403
 TClonesArray.cxx:404
 TClonesArray.cxx:405
 TClonesArray.cxx:406
 TClonesArray.cxx:407
 TClonesArray.cxx:408
 TClonesArray.cxx:409
 TClonesArray.cxx:410
 TClonesArray.cxx:411
 TClonesArray.cxx:412
 TClonesArray.cxx:413
 TClonesArray.cxx:414
 TClonesArray.cxx:415
 TClonesArray.cxx:416
 TClonesArray.cxx:417
 TClonesArray.cxx:418
 TClonesArray.cxx:419
 TClonesArray.cxx:420
 TClonesArray.cxx:421
 TClonesArray.cxx:422
 TClonesArray.cxx:423
 TClonesArray.cxx:424
 TClonesArray.cxx:425
 TClonesArray.cxx:426
 TClonesArray.cxx:427
 TClonesArray.cxx:428
 TClonesArray.cxx:429
 TClonesArray.cxx:430
 TClonesArray.cxx:431
 TClonesArray.cxx:432
 TClonesArray.cxx:433
 TClonesArray.cxx:434
 TClonesArray.cxx:435
 TClonesArray.cxx:436
 TClonesArray.cxx:437
 TClonesArray.cxx:438
 TClonesArray.cxx:439
 TClonesArray.cxx:440
 TClonesArray.cxx:441
 TClonesArray.cxx:442
 TClonesArray.cxx:443
 TClonesArray.cxx:444
 TClonesArray.cxx:445
 TClonesArray.cxx:446
 TClonesArray.cxx:447
 TClonesArray.cxx:448
 TClonesArray.cxx:449
 TClonesArray.cxx:450
 TClonesArray.cxx:451
 TClonesArray.cxx:452
 TClonesArray.cxx:453
 TClonesArray.cxx:454
 TClonesArray.cxx:455
 TClonesArray.cxx:456
 TClonesArray.cxx:457
 TClonesArray.cxx:458
 TClonesArray.cxx:459
 TClonesArray.cxx:460
 TClonesArray.cxx:461
 TClonesArray.cxx:462
 TClonesArray.cxx:463
 TClonesArray.cxx:464
 TClonesArray.cxx:465
 TClonesArray.cxx:466
 TClonesArray.cxx:467
 TClonesArray.cxx:468
 TClonesArray.cxx:469
 TClonesArray.cxx:470
 TClonesArray.cxx:471
 TClonesArray.cxx:472
 TClonesArray.cxx:473
 TClonesArray.cxx:474
 TClonesArray.cxx:475
 TClonesArray.cxx:476
 TClonesArray.cxx:477
 TClonesArray.cxx:478
 TClonesArray.cxx:479
 TClonesArray.cxx:480
 TClonesArray.cxx:481
 TClonesArray.cxx:482
 TClonesArray.cxx:483
 TClonesArray.cxx:484
 TClonesArray.cxx:485
 TClonesArray.cxx:486
 TClonesArray.cxx:487
 TClonesArray.cxx:488
 TClonesArray.cxx:489
 TClonesArray.cxx:490
 TClonesArray.cxx:491
 TClonesArray.cxx:492
 TClonesArray.cxx:493
 TClonesArray.cxx:494
 TClonesArray.cxx:495
 TClonesArray.cxx:496
 TClonesArray.cxx:497
 TClonesArray.cxx:498
 TClonesArray.cxx:499
 TClonesArray.cxx:500
 TClonesArray.cxx:501
 TClonesArray.cxx:502
 TClonesArray.cxx:503
 TClonesArray.cxx:504
 TClonesArray.cxx:505
 TClonesArray.cxx:506
 TClonesArray.cxx:507
 TClonesArray.cxx:508
 TClonesArray.cxx:509
 TClonesArray.cxx:510
 TClonesArray.cxx:511
 TClonesArray.cxx:512
 TClonesArray.cxx:513
 TClonesArray.cxx:514
 TClonesArray.cxx:515
 TClonesArray.cxx:516
 TClonesArray.cxx:517
 TClonesArray.cxx:518
 TClonesArray.cxx:519
 TClonesArray.cxx:520
 TClonesArray.cxx:521
 TClonesArray.cxx:522
 TClonesArray.cxx:523
 TClonesArray.cxx:524
 TClonesArray.cxx:525
 TClonesArray.cxx:526
 TClonesArray.cxx:527
 TClonesArray.cxx:528
 TClonesArray.cxx:529
 TClonesArray.cxx:530
 TClonesArray.cxx:531
 TClonesArray.cxx:532
 TClonesArray.cxx:533
 TClonesArray.cxx:534
 TClonesArray.cxx:535
 TClonesArray.cxx:536
 TClonesArray.cxx:537
 TClonesArray.cxx:538
 TClonesArray.cxx:539
 TClonesArray.cxx:540
 TClonesArray.cxx:541
 TClonesArray.cxx:542
 TClonesArray.cxx:543
 TClonesArray.cxx:544
 TClonesArray.cxx:545
 TClonesArray.cxx:546
 TClonesArray.cxx:547
 TClonesArray.cxx:548
 TClonesArray.cxx:549
 TClonesArray.cxx:550
 TClonesArray.cxx:551
 TClonesArray.cxx:552
 TClonesArray.cxx:553
 TClonesArray.cxx:554
 TClonesArray.cxx:555
 TClonesArray.cxx:556
 TClonesArray.cxx:557
 TClonesArray.cxx:558
 TClonesArray.cxx:559
 TClonesArray.cxx:560
 TClonesArray.cxx:561
 TClonesArray.cxx:562
 TClonesArray.cxx:563
 TClonesArray.cxx:564
 TClonesArray.cxx:565
 TClonesArray.cxx:566
 TClonesArray.cxx:567
 TClonesArray.cxx:568
 TClonesArray.cxx:569
 TClonesArray.cxx:570
 TClonesArray.cxx:571
 TClonesArray.cxx:572
 TClonesArray.cxx:573
 TClonesArray.cxx:574
 TClonesArray.cxx:575
 TClonesArray.cxx:576
 TClonesArray.cxx:577
 TClonesArray.cxx:578
 TClonesArray.cxx:579
 TClonesArray.cxx:580
 TClonesArray.cxx:581
 TClonesArray.cxx:582
 TClonesArray.cxx:583
 TClonesArray.cxx:584
 TClonesArray.cxx:585
 TClonesArray.cxx:586
 TClonesArray.cxx:587
 TClonesArray.cxx:588
 TClonesArray.cxx:589
 TClonesArray.cxx:590
 TClonesArray.cxx:591
 TClonesArray.cxx:592
 TClonesArray.cxx:593
 TClonesArray.cxx:594
 TClonesArray.cxx:595
 TClonesArray.cxx:596
 TClonesArray.cxx:597
 TClonesArray.cxx:598
 TClonesArray.cxx:599
 TClonesArray.cxx:600
 TClonesArray.cxx:601
 TClonesArray.cxx:602
 TClonesArray.cxx:603
 TClonesArray.cxx:604
 TClonesArray.cxx:605
 TClonesArray.cxx:606
 TClonesArray.cxx:607
 TClonesArray.cxx:608
 TClonesArray.cxx:609
 TClonesArray.cxx:610
 TClonesArray.cxx:611
 TClonesArray.cxx:612
 TClonesArray.cxx:613
 TClonesArray.cxx:614
 TClonesArray.cxx:615
 TClonesArray.cxx:616
 TClonesArray.cxx:617
 TClonesArray.cxx:618
 TClonesArray.cxx:619
 TClonesArray.cxx:620
 TClonesArray.cxx:621
 TClonesArray.cxx:622
 TClonesArray.cxx:623
 TClonesArray.cxx:624
 TClonesArray.cxx:625
 TClonesArray.cxx:626
 TClonesArray.cxx:627
 TClonesArray.cxx:628
 TClonesArray.cxx:629
 TClonesArray.cxx:630
 TClonesArray.cxx:631
 TClonesArray.cxx:632
 TClonesArray.cxx:633
 TClonesArray.cxx:634
 TClonesArray.cxx:635
 TClonesArray.cxx:636
 TClonesArray.cxx:637
 TClonesArray.cxx:638
 TClonesArray.cxx:639
 TClonesArray.cxx:640
 TClonesArray.cxx:641
 TClonesArray.cxx:642
 TClonesArray.cxx:643
 TClonesArray.cxx:644
 TClonesArray.cxx:645
 TClonesArray.cxx:646
 TClonesArray.cxx:647
 TClonesArray.cxx:648
 TClonesArray.cxx:649
 TClonesArray.cxx:650
 TClonesArray.cxx:651
 TClonesArray.cxx:652
 TClonesArray.cxx:653
 TClonesArray.cxx:654
 TClonesArray.cxx:655
 TClonesArray.cxx:656
 TClonesArray.cxx:657
 TClonesArray.cxx:658
 TClonesArray.cxx:659
 TClonesArray.cxx:660
 TClonesArray.cxx:661
 TClonesArray.cxx:662
 TClonesArray.cxx:663
 TClonesArray.cxx:664
 TClonesArray.cxx:665
 TClonesArray.cxx:666
 TClonesArray.cxx:667
 TClonesArray.cxx:668
 TClonesArray.cxx:669
 TClonesArray.cxx:670
 TClonesArray.cxx:671
 TClonesArray.cxx:672
 TClonesArray.cxx:673
 TClonesArray.cxx:674
 TClonesArray.cxx:675
 TClonesArray.cxx:676
 TClonesArray.cxx:677
 TClonesArray.cxx:678
 TClonesArray.cxx:679
 TClonesArray.cxx:680
 TClonesArray.cxx:681
 TClonesArray.cxx:682
 TClonesArray.cxx:683
 TClonesArray.cxx:684
 TClonesArray.cxx:685
 TClonesArray.cxx:686
 TClonesArray.cxx:687
 TClonesArray.cxx:688
 TClonesArray.cxx:689
 TClonesArray.cxx:690
 TClonesArray.cxx:691
 TClonesArray.cxx:692
 TClonesArray.cxx:693
 TClonesArray.cxx:694
 TClonesArray.cxx:695
 TClonesArray.cxx:696
 TClonesArray.cxx:697
 TClonesArray.cxx:698
 TClonesArray.cxx:699
 TClonesArray.cxx:700
 TClonesArray.cxx:701
 TClonesArray.cxx:702
 TClonesArray.cxx:703
 TClonesArray.cxx:704
 TClonesArray.cxx:705
 TClonesArray.cxx:706
 TClonesArray.cxx:707
 TClonesArray.cxx:708
 TClonesArray.cxx:709
 TClonesArray.cxx:710
 TClonesArray.cxx:711
 TClonesArray.cxx:712
 TClonesArray.cxx:713
 TClonesArray.cxx:714
 TClonesArray.cxx:715
 TClonesArray.cxx:716
 TClonesArray.cxx:717
 TClonesArray.cxx:718
 TClonesArray.cxx:719
 TClonesArray.cxx:720
 TClonesArray.cxx:721
 TClonesArray.cxx:722
 TClonesArray.cxx:723
 TClonesArray.cxx:724
 TClonesArray.cxx:725
 TClonesArray.cxx:726
 TClonesArray.cxx:727
 TClonesArray.cxx:728
 TClonesArray.cxx:729
 TClonesArray.cxx:730
 TClonesArray.cxx:731
 TClonesArray.cxx:732
 TClonesArray.cxx:733
 TClonesArray.cxx:734
 TClonesArray.cxx:735
 TClonesArray.cxx:736
 TClonesArray.cxx:737
 TClonesArray.cxx:738
 TClonesArray.cxx:739
 TClonesArray.cxx:740
 TClonesArray.cxx:741
 TClonesArray.cxx:742
 TClonesArray.cxx:743
 TClonesArray.cxx:744
 TClonesArray.cxx:745
 TClonesArray.cxx:746
 TClonesArray.cxx:747
 TClonesArray.cxx:748
 TClonesArray.cxx:749
 TClonesArray.cxx:750
 TClonesArray.cxx:751
 TClonesArray.cxx:752
 TClonesArray.cxx:753
 TClonesArray.cxx:754
 TClonesArray.cxx:755
 TClonesArray.cxx:756
 TClonesArray.cxx:757
 TClonesArray.cxx:758
 TClonesArray.cxx:759
 TClonesArray.cxx:760
 TClonesArray.cxx:761
 TClonesArray.cxx:762
 TClonesArray.cxx:763
 TClonesArray.cxx:764
 TClonesArray.cxx:765
 TClonesArray.cxx:766
 TClonesArray.cxx:767
 TClonesArray.cxx:768
 TClonesArray.cxx:769
 TClonesArray.cxx:770
 TClonesArray.cxx:771
 TClonesArray.cxx:772
 TClonesArray.cxx:773
 TClonesArray.cxx:774
 TClonesArray.cxx:775
 TClonesArray.cxx:776
 TClonesArray.cxx:777
 TClonesArray.cxx:778
 TClonesArray.cxx:779
 TClonesArray.cxx:780
 TClonesArray.cxx:781
 TClonesArray.cxx:782
 TClonesArray.cxx:783
 TClonesArray.cxx:784
 TClonesArray.cxx:785
 TClonesArray.cxx:786
 TClonesArray.cxx:787
 TClonesArray.cxx:788
 TClonesArray.cxx:789
 TClonesArray.cxx:790
 TClonesArray.cxx:791
 TClonesArray.cxx:792
 TClonesArray.cxx:793
 TClonesArray.cxx:794
 TClonesArray.cxx:795
 TClonesArray.cxx:796
 TClonesArray.cxx:797
 TClonesArray.cxx:798
 TClonesArray.cxx:799
 TClonesArray.cxx:800
 TClonesArray.cxx:801
 TClonesArray.cxx:802
 TClonesArray.cxx:803
 TClonesArray.cxx:804
 TClonesArray.cxx:805
 TClonesArray.cxx:806
 TClonesArray.cxx:807
 TClonesArray.cxx:808
 TClonesArray.cxx:809
 TClonesArray.cxx:810
 TClonesArray.cxx:811
 TClonesArray.cxx:812
 TClonesArray.cxx:813
 TClonesArray.cxx:814
 TClonesArray.cxx:815
 TClonesArray.cxx:816
 TClonesArray.cxx:817
 TClonesArray.cxx:818
 TClonesArray.cxx:819
 TClonesArray.cxx:820
 TClonesArray.cxx:821
 TClonesArray.cxx:822
 TClonesArray.cxx:823
 TClonesArray.cxx:824
 TClonesArray.cxx:825
 TClonesArray.cxx:826
 TClonesArray.cxx:827
 TClonesArray.cxx:828
 TClonesArray.cxx:829
 TClonesArray.cxx:830
 TClonesArray.cxx:831
 TClonesArray.cxx:832
 TClonesArray.cxx:833
 TClonesArray.cxx:834
 TClonesArray.cxx:835
 TClonesArray.cxx:836
 TClonesArray.cxx:837
 TClonesArray.cxx:838
 TClonesArray.cxx:839
 TClonesArray.cxx:840
 TClonesArray.cxx:841
 TClonesArray.cxx:842
 TClonesArray.cxx:843
 TClonesArray.cxx:844
 TClonesArray.cxx:845
 TClonesArray.cxx:846
 TClonesArray.cxx:847
 TClonesArray.cxx:848
 TClonesArray.cxx:849
 TClonesArray.cxx:850
 TClonesArray.cxx:851
 TClonesArray.cxx:852
 TClonesArray.cxx:853
 TClonesArray.cxx:854
 TClonesArray.cxx:855
 TClonesArray.cxx:856
 TClonesArray.cxx:857
 TClonesArray.cxx:858
 TClonesArray.cxx:859
 TClonesArray.cxx:860
 TClonesArray.cxx:861
 TClonesArray.cxx:862
 TClonesArray.cxx:863
 TClonesArray.cxx:864
 TClonesArray.cxx:865
 TClonesArray.cxx:866
 TClonesArray.cxx:867
 TClonesArray.cxx:868
 TClonesArray.cxx:869
 TClonesArray.cxx:870
 TClonesArray.cxx:871
 TClonesArray.cxx:872
 TClonesArray.cxx:873
 TClonesArray.cxx:874
 TClonesArray.cxx:875
 TClonesArray.cxx:876
 TClonesArray.cxx:877
 TClonesArray.cxx:878
 TClonesArray.cxx:879
 TClonesArray.cxx:880
 TClonesArray.cxx:881
 TClonesArray.cxx:882
 TClonesArray.cxx:883
 TClonesArray.cxx:884
 TClonesArray.cxx:885
 TClonesArray.cxx:886
 TClonesArray.cxx:887
 TClonesArray.cxx:888
 TClonesArray.cxx:889
 TClonesArray.cxx:890
 TClonesArray.cxx:891
 TClonesArray.cxx:892
 TClonesArray.cxx:893
 TClonesArray.cxx:894
 TClonesArray.cxx:895
 TClonesArray.cxx:896
 TClonesArray.cxx:897
 TClonesArray.cxx:898
 TClonesArray.cxx:899
 TClonesArray.cxx:900
 TClonesArray.cxx:901
 TClonesArray.cxx:902
 TClonesArray.cxx:903
 TClonesArray.cxx:904
 TClonesArray.cxx:905
 TClonesArray.cxx:906
 TClonesArray.cxx:907
 TClonesArray.cxx:908
 TClonesArray.cxx:909
 TClonesArray.cxx:910
 TClonesArray.cxx:911
 TClonesArray.cxx:912
 TClonesArray.cxx:913
 TClonesArray.cxx:914
 TClonesArray.cxx:915
 TClonesArray.cxx:916
 TClonesArray.cxx:917
 TClonesArray.cxx:918
 TClonesArray.cxx:919
 TClonesArray.cxx:920
 TClonesArray.cxx:921
 TClonesArray.cxx:922
 TClonesArray.cxx:923
 TClonesArray.cxx:924
 TClonesArray.cxx:925
 TClonesArray.cxx:926
 TClonesArray.cxx:927
 TClonesArray.cxx:928
 TClonesArray.cxx:929
 TClonesArray.cxx:930
 TClonesArray.cxx:931
 TClonesArray.cxx:932
 TClonesArray.cxx:933
 TClonesArray.cxx:934
 TClonesArray.cxx:935
 TClonesArray.cxx:936
 TClonesArray.cxx:937
 TClonesArray.cxx:938
 TClonesArray.cxx:939
 TClonesArray.cxx:940
 TClonesArray.cxx:941
 TClonesArray.cxx:942
 TClonesArray.cxx:943
 TClonesArray.cxx:944
 TClonesArray.cxx:945
 TClonesArray.cxx:946
 TClonesArray.cxx:947
 TClonesArray.cxx:948
 TClonesArray.cxx:949
 TClonesArray.cxx:950
 TClonesArray.cxx:951
 TClonesArray.cxx:952
 TClonesArray.cxx:953
 TClonesArray.cxx:954
 TClonesArray.cxx:955
 TClonesArray.cxx:956
 TClonesArray.cxx:957
 TClonesArray.cxx:958
 TClonesArray.cxx:959
 TClonesArray.cxx:960
 TClonesArray.cxx:961
 TClonesArray.cxx:962
 TClonesArray.cxx:963
 TClonesArray.cxx:964
 TClonesArray.cxx:965
 TClonesArray.cxx:966
 TClonesArray.cxx:967
 TClonesArray.cxx:968
 TClonesArray.cxx:969
 TClonesArray.cxx:970
 TClonesArray.cxx:971
 TClonesArray.cxx:972
 TClonesArray.cxx:973
 TClonesArray.cxx:974
 TClonesArray.cxx:975
 TClonesArray.cxx:976
 TClonesArray.cxx:977
 TClonesArray.cxx:978
 TClonesArray.cxx:979
 TClonesArray.cxx:980
 TClonesArray.cxx:981
 TClonesArray.cxx:982
 TClonesArray.cxx:983
 TClonesArray.cxx:984
 TClonesArray.cxx:985
 TClonesArray.cxx:986
 TClonesArray.cxx:987
 TClonesArray.cxx:988
 TClonesArray.cxx:989
 TClonesArray.cxx:990
 TClonesArray.cxx:991
 TClonesArray.cxx:992
 TClonesArray.cxx:993
 TClonesArray.cxx:994
 TClonesArray.cxx:995
 TClonesArray.cxx:996
 TClonesArray.cxx:997
 TClonesArray.cxx:998
 TClonesArray.cxx:999
 TClonesArray.cxx:1000
 TClonesArray.cxx:1001
 TClonesArray.cxx:1002
 TClonesArray.cxx:1003
 TClonesArray.cxx:1004
 TClonesArray.cxx:1005
 TClonesArray.cxx:1006
 TClonesArray.cxx:1007
 TClonesArray.cxx:1008
 TClonesArray.cxx:1009
 TClonesArray.cxx:1010
 TClonesArray.cxx:1011
 TClonesArray.cxx:1012
 TClonesArray.cxx:1013
 TClonesArray.cxx:1014
 TClonesArray.cxx:1015
 TClonesArray.cxx:1016
 TClonesArray.cxx:1017
 TClonesArray.cxx:1018
 TClonesArray.cxx:1019
 TClonesArray.cxx:1020
 TClonesArray.cxx:1021
 TClonesArray.cxx:1022
 TClonesArray.cxx:1023
 TClonesArray.cxx:1024
 TClonesArray.cxx:1025
 TClonesArray.cxx:1026
 TClonesArray.cxx:1027
 TClonesArray.cxx:1028
 TClonesArray.cxx:1029
 TClonesArray.cxx:1030
 TClonesArray.cxx:1031
 TClonesArray.cxx:1032
 TClonesArray.cxx:1033
 TClonesArray.cxx:1034
 TClonesArray.cxx:1035
 TClonesArray.cxx:1036
 TClonesArray.cxx:1037
 TClonesArray.cxx:1038
 TClonesArray.cxx:1039
 TClonesArray.cxx:1040
 TClonesArray.cxx:1041
 TClonesArray.cxx:1042
 TClonesArray.cxx:1043
 TClonesArray.cxx:1044
 TClonesArray.cxx:1045
 TClonesArray.cxx:1046
 TClonesArray.cxx:1047
 TClonesArray.cxx:1048
 TClonesArray.cxx:1049
 TClonesArray.cxx:1050
 TClonesArray.cxx:1051
 TClonesArray.cxx:1052
 TClonesArray.cxx:1053
 TClonesArray.cxx:1054
 TClonesArray.cxx:1055
 TClonesArray.cxx:1056
 TClonesArray.cxx:1057
 TClonesArray.cxx:1058
 TClonesArray.cxx:1059
 TClonesArray.cxx:1060
 TClonesArray.cxx:1061
 TClonesArray.cxx:1062
 TClonesArray.cxx:1063
 TClonesArray.cxx:1064
 TClonesArray.cxx:1065
 TClonesArray.cxx:1066
 TClonesArray.cxx:1067
 TClonesArray.cxx:1068
 TClonesArray.cxx:1069
 TClonesArray.cxx:1070
 TClonesArray.cxx:1071
 TClonesArray.cxx:1072
 TClonesArray.cxx:1073
 TClonesArray.cxx:1074
 TClonesArray.cxx:1075
 TClonesArray.cxx:1076
 TClonesArray.cxx:1077
 TClonesArray.cxx:1078
 TClonesArray.cxx:1079
 TClonesArray.cxx:1080
 TClonesArray.cxx:1081
 TClonesArray.cxx:1082
 TClonesArray.cxx:1083
 TClonesArray.cxx:1084
 TClonesArray.cxx:1085
 TClonesArray.cxx:1086
 TClonesArray.cxx:1087
 TClonesArray.cxx:1088
 TClonesArray.cxx:1089
 TClonesArray.cxx:1090
 TClonesArray.cxx:1091
 TClonesArray.cxx:1092
 TClonesArray.cxx:1093
 TClonesArray.cxx:1094
 TClonesArray.cxx:1095
 TClonesArray.cxx:1096
 TClonesArray.cxx:1097
 TClonesArray.cxx:1098
 TClonesArray.cxx:1099
 TClonesArray.cxx:1100
 TClonesArray.cxx:1101
 TClonesArray.cxx:1102
 TClonesArray.cxx:1103
 TClonesArray.cxx:1104
 TClonesArray.cxx:1105
 TClonesArray.cxx:1106
 TClonesArray.cxx:1107
 TClonesArray.cxx:1108
 TClonesArray.cxx:1109
 TClonesArray.cxx:1110
 TClonesArray.cxx:1111
 TClonesArray.cxx:1112
 TClonesArray.cxx:1113
 TClonesArray.cxx:1114
 TClonesArray.cxx:1115
 TClonesArray.cxx:1116
 TClonesArray.cxx:1117
 TClonesArray.cxx:1118
 TClonesArray.cxx:1119
 TClonesArray.cxx:1120
 TClonesArray.cxx:1121