ROOT logo
// @(#)root/cont:$Id$
// Author: Fons Rademakers   10/10/95

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

#ifndef ROOT_TBtree
#define ROOT_TBtree


//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TBtree                                                               //
//                                                                      //
// Btree class. TBtree inherits from the TSeqCollection ABC.            //
//                                                                      //
// For a more extensive algorithmic description see the TBtree source.  //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

#ifndef ROOT_TSeqCollection
#include "TSeqCollection.h"
#endif
#ifndef ROOT_TError
#include "TError.h"
#endif

#include <iterator>


class TBtNode;
class TBtInnerNode;
class TBtLeafNode;
class TBtreeIter;


class TBtree : public TSeqCollection {

friend class  TBtNode;
friend class  TBtInnerNode;
friend class  TBtLeafNode;

private:
   TBtNode  *fRoot;              //root node of btree

   Int_t     fOrder;             //the order of the tree (should be > 2)
   Int_t     fOrder2;            //order*2+1 (assumes a memory access is
                                 //cheaper than a multiply and increment by one
   Int_t     fInnerLowWaterMark; //inner node low water mark
   Int_t     fLeafLowWaterMark;  //leaf low water mark
   Int_t     fInnerMaxIndex;     //maximum inner node index
   Int_t     fLeafMaxIndex;      //maximum leaf index

   void Init(Int_t i);        //initialize btree
   void RootIsFull();         //called when the root node is full
   void RootIsEmpty();        //called when root is empty

protected:
   void IncrNofKeys() { fSize++; }
   void DecrNofKeys() { fSize--; }

   // add the object to the tree; return the index in the tree at which
   // the object was inserted. NOTE: other insertions and deletions may
   // change this object's index.
   Int_t IdxAdd(const TObject &obj);

public:
   typedef TBtreeIter Iterator_t;

   TBtree(Int_t ordern = 3);  //create a TBtree of order n
   virtual     ~TBtree();
   void        Clear(Option_t *option="");
   void        Delete(Option_t *option="");
   TObject    *FindObject(const char *name) const;
   TObject    *FindObject(const TObject *obj) const;
   TObject   **GetObjectRef(const TObject *) const { return 0; }
   TIterator  *MakeIterator(Bool_t dir = kIterForward) const;

   void        Add(TObject *obj);
   void        AddFirst(TObject *obj) { Add(obj); }
   void        AddLast(TObject *obj) { Add(obj); }
   void        AddAt(TObject *obj, Int_t) { Add(obj); }
   void        AddAfter(const TObject *, TObject *obj) { Add(obj); }
   void        AddBefore(const TObject *, TObject *obj) { Add(obj); }
   TObject    *Remove(TObject *obj);

   TObject    *At(Int_t idx) const;
   TObject    *Before(const TObject *obj) const;
   TObject    *After(const TObject *obj) const;
   TObject    *First() const;
   TObject    *Last() const;

   //void PrintOn(ostream &os) const;

   Int_t       Order() { return fOrder; }
   TObject    *operator[](Int_t i) const;
   Int_t       Rank(const TObject *obj) const;

   ClassDef(TBtree,0)  //A B-tree
};


//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TBtNode                                                              //
//                                                                      //
// Abstract base class (ABC) of a TBtree node.                          //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

class TBtNode {

friend class  TBtree;
friend class  TBtInnerNode;
friend class  TBtLeafNode;

protected:
   Int_t fLast;   // for inner node 1 <= fLast <= fInnerMaxIndex
                  // for leaf node  1 <= fLast <= fLeafMaxIndex
                  // (fLast==0 only temporarily while the tree is being
                  // updated)

   TBtInnerNode *fParent;   // a parent is always an inner node (or 0 for the root)
   TBtree       *fTree;     // the tree of which this node is a part
   Int_t         fIsLeaf;   // run-time type flag

public:
   TBtNode(Int_t isleaf, TBtInnerNode *p, TBtree *t = 0);
   virtual ~TBtNode();

   virtual void Add(const TObject *obj, Int_t index) = 0;
#ifndef __CINT__
   virtual TBtree *GetParentTree() const {return fTree;}
   virtual void Remove(Int_t index) = 0;

   virtual TObject *operator[](Int_t i) const = 0;
   virtual TObject *Found(const TObject *obj, TBtNode **which, Int_t *where) = 0;

   virtual Int_t FindRank(const TObject *obj) const = 0;
   virtual Int_t NofKeys() const = 0; // # keys in or below this node

   virtual TBtLeafNode *FirstLeafNode() = 0;
   virtual TBtLeafNode *LastLeafNode() = 0;

   virtual void Split() = 0;
#endif
   // virtual void PrintOn(ostream &os) const = 0;
   // friend ostream &operator<<(ostream &os, const TBtNode &node);
};


//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TBtItem                                                              //
//                                                                      //
// Item stored in inner nodes of a TBtree.                              //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

class TBtItem {

friend class  TBtInnerNode;

private:
   Int_t      fNofKeysInTree;   // number of keys in TBtree
   TObject   *fKey;             // key
   TBtNode   *fTree;            //! sub-tree

public:
   TBtItem();
   TBtItem(TBtNode *n, TObject *o);
   TBtItem(TObject *o, TBtNode *n);
   ~TBtItem();
};


//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TBtInnerNode                                                         //
//                                                                      //
// Inner node of a TBtree.                                              //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

class TBtInnerNode : public TBtNode {

private:
   TBtItem    *fItem;   // actually fItem[MaxIndex()+1] is desired

public:
   TBtInnerNode(TBtInnerNode *parent, TBtree *t = 0);
   TBtInnerNode(TBtInnerNode *parent, TBtree *tree, TBtNode *oldroot);
   ~TBtInnerNode();

#ifndef __CINT__
   void      Add(const TObject *obj, Int_t idx);
   void      Add(TBtItem &i, Int_t idx);
   void      Add(Int_t at, TObject *obj, TBtNode *n);
   void      AddElt(TBtItem &itm, Int_t at);
   void      AddElt(Int_t at, TObject *obj, TBtNode *n);
   void      Remove(Int_t idx);
   void      RemoveItem(Int_t idx);

   TObject  *operator[](Int_t i) const;
   TObject  *Found(const TObject *obj, TBtNode **which, Int_t *where);

   Int_t     NofKeys(Int_t idx) const;
   Int_t     NofKeys() const;
   void      SetTree(Int_t i, TBtNode *node) { fItem[i].fTree = node; node->fParent = this; }
   void      SetKey(Int_t i, TObject *obj) { fItem[i].fKey = obj; }
   void      SetItem(Int_t i, TBtItem &itm) { fItem[i] = itm; itm.fTree->fParent = this; }
   void      SetItem(Int_t i, TObject *obj, TBtNode *node) { SetTree(i, node); SetKey(i, obj); }
   Int_t     GetNofKeys(Int_t i) const;
   void      SetNofKeys(Int_t i, Int_t r);
   Int_t     IncNofKeys(Int_t i, Int_t n=1);
   Int_t     DecNofKeys(Int_t i, Int_t n=1);
   Int_t     FindRank(const TObject *obj) const;
   Int_t     FindRankUp(const TBtNode *n) const;
   TBtNode  *GetTree(Int_t i) const { return fItem[i].fTree; }
   TObject  *GetKey(Int_t i) const { return fItem[i].fKey; }
   TBtItem  &GetItem(Int_t i) const { return fItem[i]; }

   Int_t     IndexOf(const TBtNode *n) const;
   void      IncrNofKeys(TBtNode *np);
   void      DecrNofKeys(TBtNode *np);

   TBtLeafNode *FirstLeafNode();
   TBtLeafNode *LastLeafNode();

   void      InformParent();

   void      Split();
   void      SplitWith(TBtInnerNode *r, Int_t idx);
   void      MergeWithRight(TBtInnerNode *r, Int_t idx);
   void      BalanceWithLeft(TBtInnerNode *l, Int_t idx);
   void      BalanceWithRight(TBtInnerNode *r, Int_t idx);
   void      BalanceWith(TBtInnerNode *n, int idx);
   void      PushLeft(Int_t cnt, TBtInnerNode *leftsib, Int_t parentIdx);
   void      PushRight(Int_t cnt, TBtInnerNode *rightsib, Int_t parentIdx);
   void      AppendFrom(TBtInnerNode *src, Int_t start, Int_t stop);
   void      Append(TObject *obj, TBtNode *n);
   void      Append(TBtItem &itm);
   void      ShiftLeft(Int_t cnt);

   Int_t     Psize() const { return fLast; }
   Int_t     Vsize() const;
   Int_t     MaxIndex() const { return fTree->fInnerMaxIndex; }
   Int_t     MaxPsize() const { return fTree->fInnerMaxIndex; }

   // void      PrintOn(ostream &os) const;

   Int_t     IsFull() const { return fLast == MaxIndex(); }
   void      IsFull(TBtNode *n);
   Int_t     IsAlmostFull() const { return fLast >= MaxIndex() - 1; }
   Int_t     IsLow() const {  return fLast < fTree->fInnerLowWaterMark; }
   void      IsLow(TBtNode *n);
#endif
};


//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TBtLeafNode                                                          //
//                                                                      //
// Leaf node of a TBtree.                                               //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

class TBtLeafNode : public TBtNode {

friend class  TBtInnerNode;

private:
   TObject **fItem; // actually TObject *fItem[MaxIndex()+1] is desired

public:
   TBtLeafNode(TBtInnerNode *p, const TObject *obj = 0, TBtree *t = 0);
   ~TBtLeafNode();

#ifndef __CINT__
   void       Add(const TObject *obj, Int_t idx);
   void       Remove(Int_t idx);
   void       RemoveItem(Int_t idx) { Remove(idx); }

   TObject   *operator[](Int_t i) const;
   TObject   *Found(const TObject *obj, TBtNode **which, Int_t *where);

   Int_t      NofKeys(Int_t i) const;
   Int_t      NofKeys() const;
   Int_t      FindRank(const TObject *obj) const;
   TObject   *GetKey(Int_t idx ) { return fItem[idx]; }
   void       SetKey(Int_t idx, TObject *obj) { fItem[idx] = obj; }

   Int_t      IndexOf(const TObject *obj) const;

   TBtLeafNode  *FirstLeafNode();
   TBtLeafNode  *LastLeafNode();

   void       Split();
   void       SplitWith(TBtLeafNode *r, Int_t idx);
   void       MergeWithRight(TBtLeafNode *r, Int_t idx);
   void       BalanceWithLeft(TBtLeafNode *l, Int_t idx);
   void       BalanceWithRight(TBtLeafNode *r, Int_t idx);
   void       BalanceWith(TBtLeafNode *n, Int_t idx);
   void       PushLeft(Int_t cnt, TBtLeafNode *l, Int_t parentIndex);
   void       PushRight(Int_t cnt, TBtLeafNode *r, Int_t parentIndex);
   void       AppendFrom(TBtLeafNode *src, Int_t start, Int_t stop);
   void       Append(TObject *obj);
   void       ShiftLeft(Int_t cnt);

   Int_t      Psize() const { return fLast + 1; }
   Int_t      Vsize() const;
   Int_t      MaxIndex() const { return fTree->fLeafMaxIndex; }
   Int_t      MaxPsize() const { return fTree->fLeafMaxIndex + 1; }

   // void       PrintOn(ostream &os) const;

   Int_t      IsFull() const { return fLast == MaxIndex(); }
   Int_t      IsAlmostFull() const { return fLast >= MaxIndex() - 1; }
   Int_t      IsLow() const { return fLast < fTree->fLeafLowWaterMark; }
#endif
};


//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TBtreeIter                                                           //
//                                                                      //
// Iterator of btree.                                                   //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

class TBtreeIter : public TIterator,
                   public std::iterator<std::bidirectional_iterator_tag,
                                        TObject*, std::ptrdiff_t,
                                        const TObject**, const TObject*&> {

private:
   const TBtree  *fTree;      //btree being iterated
   Int_t          fCurCursor; //current position in btree
   Int_t          fCursor;    //next position in btree
   Bool_t         fDirection; //iteration direction

   TBtreeIter() : fTree(0), fCurCursor(0), fCursor(0), fDirection(kIterForward) { }

public:
   TBtreeIter(const TBtree *t, Bool_t dir = kIterForward);
   TBtreeIter(const TBtreeIter &iter);
   ~TBtreeIter() { }
   TIterator  &operator=(const TIterator &rhs);
   TBtreeIter &operator=(const TBtreeIter &rhs);

   const TCollection  *GetCollection() const { return fTree; }
   TObject            *Next();
   void                Reset();
   Bool_t              operator!=(const TIterator &aIter) const;
   Bool_t              operator!=(const TBtreeIter &aIter) const;
   TObject            *operator*() const;

   ClassDef(TBtreeIter,0)  //B-tree iterator
};


//----- TBtree inlines ---------------------------------------------------------

inline TObject *TBtree::operator[](Int_t i) const
{
   return (*fRoot)[i];
}

inline TObject *TBtree::At(Int_t i) const
{
   return (*fRoot)[i];
}

inline TObject *TBtree::First() const
{
   return (*fRoot)[0];
}

inline TObject *TBtree::Last() const
{
   return (*fRoot)[fSize-1];
}

//----- TBtInnerNode inlines ---------------------------------------------------

inline Int_t TBtInnerNode::GetNofKeys(Int_t i) const
{
   R__ASSERT(i >= 0 && i <= fLast);
   return fItem[i].fNofKeysInTree;
}

inline Int_t TBtInnerNode::NofKeys(Int_t idx) const
{
   return GetNofKeys(idx);
}

inline void TBtInnerNode::SetNofKeys(Int_t i, Int_t r)
{
   fItem[i].fNofKeysInTree = r;
}

inline Int_t TBtInnerNode::IncNofKeys(Int_t i, Int_t n)
{
   return (fItem[i].fNofKeysInTree += n);
}

inline Int_t TBtInnerNode::DecNofKeys(Int_t i, Int_t n)
{
   return (fItem[i].fNofKeysInTree -= n);
}

inline Int_t TBtInnerNode::Vsize() const
{
   R__ASSERT(fParent != 0 && fParent->GetTree(0) != (TBtNode *)this);
   return Psize()+1;
}


//----- TBtLeafNode inlines ----------------------------------------------------

inline TObject *TBtLeafNode::operator[](Int_t i) const
{
   R__ASSERT(i >= 0 && i <= fLast);
   return fItem[i];
}

inline Int_t TBtLeafNode::Vsize() const
{
   R__ASSERT(fParent != 0 && fParent->GetTree(0) != (TBtNode *)this);
   return Psize()+1;
}

//inline ostream &operator<<(ostream& outputStream, const TBtNode &aNode)
//{
//   aNode.PrintOn(outputStream);
//   return outputStream;
//}

#endif
 TBtree.h:1
 TBtree.h:2
 TBtree.h:3
 TBtree.h:4
 TBtree.h:5
 TBtree.h:6
 TBtree.h:7
 TBtree.h:8
 TBtree.h:9
 TBtree.h:10
 TBtree.h:11
 TBtree.h:12
 TBtree.h:13
 TBtree.h:14
 TBtree.h:15
 TBtree.h:16
 TBtree.h:17
 TBtree.h:18
 TBtree.h:19
 TBtree.h:20
 TBtree.h:21
 TBtree.h:22
 TBtree.h:23
 TBtree.h:24
 TBtree.h:25
 TBtree.h:26
 TBtree.h:27
 TBtree.h:28
 TBtree.h:29
 TBtree.h:30
 TBtree.h:31
 TBtree.h:32
 TBtree.h:33
 TBtree.h:34
 TBtree.h:35
 TBtree.h:36
 TBtree.h:37
 TBtree.h:38
 TBtree.h:39
 TBtree.h:40
 TBtree.h:41
 TBtree.h:42
 TBtree.h:43
 TBtree.h:44
 TBtree.h:45
 TBtree.h:46
 TBtree.h:47
 TBtree.h:48
 TBtree.h:49
 TBtree.h:50
 TBtree.h:51
 TBtree.h:52
 TBtree.h:53
 TBtree.h:54
 TBtree.h:55
 TBtree.h:56
 TBtree.h:57
 TBtree.h:58
 TBtree.h:59
 TBtree.h:60
 TBtree.h:61
 TBtree.h:62
 TBtree.h:63
 TBtree.h:64
 TBtree.h:65
 TBtree.h:66
 TBtree.h:67
 TBtree.h:68
 TBtree.h:69
 TBtree.h:70
 TBtree.h:71
 TBtree.h:72
 TBtree.h:73
 TBtree.h:74
 TBtree.h:75
 TBtree.h:76
 TBtree.h:77
 TBtree.h:78
 TBtree.h:79
 TBtree.h:80
 TBtree.h:81
 TBtree.h:82
 TBtree.h:83
 TBtree.h:84
 TBtree.h:85
 TBtree.h:86
 TBtree.h:87
 TBtree.h:88
 TBtree.h:89
 TBtree.h:90
 TBtree.h:91
 TBtree.h:92
 TBtree.h:93
 TBtree.h:94
 TBtree.h:95
 TBtree.h:96
 TBtree.h:97
 TBtree.h:98
 TBtree.h:99
 TBtree.h:100
 TBtree.h:101
 TBtree.h:102
 TBtree.h:103
 TBtree.h:104
 TBtree.h:105
 TBtree.h:106
 TBtree.h:107
 TBtree.h:108
 TBtree.h:109
 TBtree.h:110
 TBtree.h:111
 TBtree.h:112
 TBtree.h:113
 TBtree.h:114
 TBtree.h:115
 TBtree.h:116
 TBtree.h:117
 TBtree.h:118
 TBtree.h:119
 TBtree.h:120
 TBtree.h:121
 TBtree.h:122
 TBtree.h:123
 TBtree.h:124
 TBtree.h:125
 TBtree.h:126
 TBtree.h:127
 TBtree.h:128
 TBtree.h:129
 TBtree.h:130
 TBtree.h:131
 TBtree.h:132
 TBtree.h:133
 TBtree.h:134
 TBtree.h:135
 TBtree.h:136
 TBtree.h:137
 TBtree.h:138
 TBtree.h:139
 TBtree.h:140
 TBtree.h:141
 TBtree.h:142
 TBtree.h:143
 TBtree.h:144
 TBtree.h:145
 TBtree.h:146
 TBtree.h:147
 TBtree.h:148
 TBtree.h:149
 TBtree.h:150
 TBtree.h:151
 TBtree.h:152
 TBtree.h:153
 TBtree.h:154
 TBtree.h:155
 TBtree.h:156
 TBtree.h:157
 TBtree.h:158
 TBtree.h:159
 TBtree.h:160
 TBtree.h:161
 TBtree.h:162
 TBtree.h:163
 TBtree.h:164
 TBtree.h:165
 TBtree.h:166
 TBtree.h:167
 TBtree.h:168
 TBtree.h:169
 TBtree.h:170
 TBtree.h:171
 TBtree.h:172
 TBtree.h:173
 TBtree.h:174
 TBtree.h:175
 TBtree.h:176
 TBtree.h:177
 TBtree.h:178
 TBtree.h:179
 TBtree.h:180
 TBtree.h:181
 TBtree.h:182
 TBtree.h:183
 TBtree.h:184
 TBtree.h:185
 TBtree.h:186
 TBtree.h:187
 TBtree.h:188
 TBtree.h:189
 TBtree.h:190
 TBtree.h:191
 TBtree.h:192
 TBtree.h:193
 TBtree.h:194
 TBtree.h:195
 TBtree.h:196
 TBtree.h:197
 TBtree.h:198
 TBtree.h:199
 TBtree.h:200
 TBtree.h:201
 TBtree.h:202
 TBtree.h:203
 TBtree.h:204
 TBtree.h:205
 TBtree.h:206
 TBtree.h:207
 TBtree.h:208
 TBtree.h:209
 TBtree.h:210
 TBtree.h:211
 TBtree.h:212
 TBtree.h:213
 TBtree.h:214
 TBtree.h:215
 TBtree.h:216
 TBtree.h:217
 TBtree.h:218
 TBtree.h:219
 TBtree.h:220
 TBtree.h:221
 TBtree.h:222
 TBtree.h:223
 TBtree.h:224
 TBtree.h:225
 TBtree.h:226
 TBtree.h:227
 TBtree.h:228
 TBtree.h:229
 TBtree.h:230
 TBtree.h:231
 TBtree.h:232
 TBtree.h:233
 TBtree.h:234
 TBtree.h:235
 TBtree.h:236
 TBtree.h:237
 TBtree.h:238
 TBtree.h:239
 TBtree.h:240
 TBtree.h:241
 TBtree.h:242
 TBtree.h:243
 TBtree.h:244
 TBtree.h:245
 TBtree.h:246
 TBtree.h:247
 TBtree.h:248
 TBtree.h:249
 TBtree.h:250
 TBtree.h:251
 TBtree.h:252
 TBtree.h:253
 TBtree.h:254
 TBtree.h:255
 TBtree.h:256
 TBtree.h:257
 TBtree.h:258
 TBtree.h:259
 TBtree.h:260
 TBtree.h:261
 TBtree.h:262
 TBtree.h:263
 TBtree.h:264
 TBtree.h:265
 TBtree.h:266
 TBtree.h:267
 TBtree.h:268
 TBtree.h:269
 TBtree.h:270
 TBtree.h:271
 TBtree.h:272
 TBtree.h:273
 TBtree.h:274
 TBtree.h:275
 TBtree.h:276
 TBtree.h:277
 TBtree.h:278
 TBtree.h:279
 TBtree.h:280
 TBtree.h:281
 TBtree.h:282
 TBtree.h:283
 TBtree.h:284
 TBtree.h:285
 TBtree.h:286
 TBtree.h:287
 TBtree.h:288
 TBtree.h:289
 TBtree.h:290
 TBtree.h:291
 TBtree.h:292
 TBtree.h:293
 TBtree.h:294
 TBtree.h:295
 TBtree.h:296
 TBtree.h:297
 TBtree.h:298
 TBtree.h:299
 TBtree.h:300
 TBtree.h:301
 TBtree.h:302
 TBtree.h:303
 TBtree.h:304
 TBtree.h:305
 TBtree.h:306
 TBtree.h:307
 TBtree.h:308
 TBtree.h:309
 TBtree.h:310
 TBtree.h:311
 TBtree.h:312
 TBtree.h:313
 TBtree.h:314
 TBtree.h:315
 TBtree.h:316
 TBtree.h:317
 TBtree.h:318
 TBtree.h:319
 TBtree.h:320
 TBtree.h:321
 TBtree.h:322
 TBtree.h:323
 TBtree.h:324
 TBtree.h:325
 TBtree.h:326
 TBtree.h:327
 TBtree.h:328
 TBtree.h:329
 TBtree.h:330
 TBtree.h:331
 TBtree.h:332
 TBtree.h:333
 TBtree.h:334
 TBtree.h:335
 TBtree.h:336
 TBtree.h:337
 TBtree.h:338
 TBtree.h:339
 TBtree.h:340
 TBtree.h:341
 TBtree.h:342
 TBtree.h:343
 TBtree.h:344
 TBtree.h:345
 TBtree.h:346
 TBtree.h:347
 TBtree.h:348
 TBtree.h:349
 TBtree.h:350
 TBtree.h:351
 TBtree.h:352
 TBtree.h:353
 TBtree.h:354
 TBtree.h:355
 TBtree.h:356
 TBtree.h:357
 TBtree.h:358
 TBtree.h:359
 TBtree.h:360
 TBtree.h:361
 TBtree.h:362
 TBtree.h:363
 TBtree.h:364
 TBtree.h:365
 TBtree.h:366
 TBtree.h:367
 TBtree.h:368
 TBtree.h:369
 TBtree.h:370
 TBtree.h:371
 TBtree.h:372
 TBtree.h:373
 TBtree.h:374
 TBtree.h:375
 TBtree.h:376
 TBtree.h:377
 TBtree.h:378
 TBtree.h:379
 TBtree.h:380
 TBtree.h:381
 TBtree.h:382
 TBtree.h:383
 TBtree.h:384
 TBtree.h:385
 TBtree.h:386
 TBtree.h:387
 TBtree.h:388
 TBtree.h:389
 TBtree.h:390
 TBtree.h:391
 TBtree.h:392
 TBtree.h:393
 TBtree.h:394
 TBtree.h:395
 TBtree.h:396
 TBtree.h:397
 TBtree.h:398
 TBtree.h:399
 TBtree.h:400
 TBtree.h:401
 TBtree.h:402
 TBtree.h:403
 TBtree.h:404
 TBtree.h:405
 TBtree.h:406
 TBtree.h:407
 TBtree.h:408
 TBtree.h:409
 TBtree.h:410
 TBtree.h:411
 TBtree.h:412
 TBtree.h:413
 TBtree.h:414
 TBtree.h:415
 TBtree.h:416
 TBtree.h:417
 TBtree.h:418
 TBtree.h:419
 TBtree.h:420
 TBtree.h:421
 TBtree.h:422
 TBtree.h:423
 TBtree.h:424
 TBtree.h:425
 TBtree.h:426
 TBtree.h:427
 TBtree.h:428
 TBtree.h:429
 TBtree.h:430
 TBtree.h:431
 TBtree.h:432
 TBtree.h:433
 TBtree.h:434
 TBtree.h:435
 TBtree.h:436
 TBtree.h:437
 TBtree.h:438
 TBtree.h:439
 TBtree.h:440
 TBtree.h:441
 TBtree.h:442
 TBtree.h:443
 TBtree.h:444
 TBtree.h:445
 TBtree.h:446