// @(#)root/sql:$Id$
// Author: Sergey Linev  20/11/2005

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

//________________________________________________________________________
//
// Class for serializing/deserializing object to/from SQL data base.
// It redefines most of TBuffer class function to convert simple types,
// array of simple types and objects to/from TSQLStructure objects.
// TBufferSQL2 class uses streaming mechanism, provided by ROOT system,
// therefore most of ROOT and user classes can be stored. There are
// limitations for complex objects like TTree, TClonesArray, TDirectory and
// few other, which can not be converted to SQL (yet).
//________________________________________________________________________

#include "TBufferSQL2.h"

#include "TObjArray.h"
#include "TROOT.h"
#include "TDataType.h"
#include "TClass.h"
#include "TClassTable.h"
#include "TMap.h"
#include "TExMap.h"
#include "TMethodCall.h"
#include "TStreamerInfo.h"
#include "TStreamerElement.h"
#include "TProcessID.h"
#include "TFile.h"
#include "TMemberStreamer.h"
#include "TStreamer.h"
#include "Riostream.h"
#include <stdlib.h>
#include "TStreamerInfoActions.h"

#include "TSQLServer.h"
#include "TSQLResult.h"
#include "TSQLRow.h"
#include "TSQLStructure.h"
#include "TSQLObjectData.h"
#include "TSQLFile.h"
#include "TSQLClassInfo.h"

#ifdef R__VISUAL_CPLUSPLUS
#define FLong64    "%I64d"
#define FULong64   "%I64u"
#else
#define FLong64    "%lld"
#define FULong64   "%llu"
#endif

ClassImp(TBufferSQL2);

//______________________________________________________________________________
TBufferSQL2::TBufferSQL2() :
   TBufferFile(),
   fSQL(0),
   fStructure(0),
   fStk(0),
   fObjMap(0),
   fReadBuffer(),
   fErrorFlag(0),
   fExpectedChain(kFALSE),
   fCompressLevel(0),
   fReadVersionBuffer(-1),
   fObjIdCounter(1),
   fIgnoreVerification(kFALSE),
   fCurrentData(0),
   fObjectsInfos(0),
   fFirstObjId(0),
   fLastObjId(0),
   fPoolsMap(0)
{
   // Default constructor, should not be used
}

//______________________________________________________________________________
TBufferSQL2::TBufferSQL2(TBuffer::EMode mode) :
   TBufferFile(mode),
   fSQL(0),
   fStructure(0),
   fStk(0),
   fObjMap(0),
   fReadBuffer(),
   fErrorFlag(0),
   fExpectedChain(kFALSE),
   fCompressLevel(0),
   fReadVersionBuffer(-1),
   fObjIdCounter(1),
   fIgnoreVerification(kFALSE),
   fCurrentData(0),
   fObjectsInfos(0),
   fFirstObjId(0),
   fLastObjId(0),
   fPoolsMap(0)
{
   // Creates buffer object to serailize/deserialize data to/from sql.
   // Mode should be either TBuffer::kRead or TBuffer::kWrite.

   SetParent(0);
   SetBit(kCannotHandleMemberWiseStreaming);
   SetBit(kTextBasedStreaming);
}

//______________________________________________________________________________
TBufferSQL2::TBufferSQL2(TBuffer::EMode mode, TSQLFile* file) :
   TBufferFile(mode),
   fSQL(0),
   fStructure(0),
   fStk(0),
   fObjMap(0),
   fReadBuffer(),
   fErrorFlag(0),
   fExpectedChain(kFALSE),
   fCompressLevel(0),
   fReadVersionBuffer(-1),
   fObjIdCounter(1),
   fIgnoreVerification(kFALSE),
   fCurrentData(0),
   fObjectsInfos(0),
   fFirstObjId(0),
   fLastObjId(0),
   fPoolsMap(0)
{
   // Creates buffer object to serailize/deserialize data to/from sql.
   // This constructor should be used, if data from buffer supposed to be stored in file.
   // Mode should be either TBuffer::kRead or TBuffer::kWrite.

   fBufSize = 1000000000;

   // for TClonesArray recognize if this is special case
   SetBit(kCannotHandleMemberWiseStreaming);
   SetBit(kTextBasedStreaming);

   SetParent(file);
   fSQL = file;
   if (file!=0)
      SetCompressionLevel(file->GetCompressionLevel());
}

//______________________________________________________________________________
TBufferSQL2::~TBufferSQL2()
{
   // destroy sql buffer
   if (fObjMap) delete fObjMap;

   if (fStructure!=0) {
      delete fStructure;
      fStructure = 0;
   }

   if (fObjectsInfos!=0) {
      fObjectsInfos->Delete();
      delete fObjectsInfos;
   }

   if (fPoolsMap!=0) {
      fPoolsMap->DeleteValues();
      delete fPoolsMap;
   }
}

//______________________________________________________________________________
TSQLStructure* TBufferSQL2::SqlWriteAny(const void* obj, const TClass* cl, Long64_t objid)
{
   // Convert object of any class to sql structures
   // Return pointer on created TSQLStructure
   // TSQLStructure object will be owned by TBufferSQL2

   fErrorFlag = 0;

   fStructure = 0;

   fFirstObjId = objid;
   fObjIdCounter = objid;

   SqlWriteObject(obj, cl);

   if (gDebug>3)
      if (fStructure!=0) {
         std::cout << "==== Printout of Sql structures ===== " << std::endl;
         fStructure->Print("*");
         std::cout << "=========== End printout ============ " << std::endl;
      }

   return fStructure;
}

//______________________________________________________________________________
void* TBufferSQL2::SqlReadAny(Long64_t keyid, Long64_t objid, TClass** cl, void* obj)
{
   // Recreate object from sql structure.
   // Return pointer to read object.
   // if (cl!=0) returns pointer to class of object

   if (cl) *cl = 0;
   if (fSQL==0) return 0;

   fCurrentData = 0;
   fErrorFlag = 0;

   fReadVersionBuffer = -1;

   fObjectsInfos = fSQL->SQLObjectsInfo(keyid);
//   fObjectsInfos = 0;
   fFirstObjId = objid;
   fLastObjId = objid;
   if (fObjectsInfos!=0) {
      TSQLObjectInfo* objinfo = (TSQLObjectInfo*) fObjectsInfos->Last();
      if (objinfo!=0) fLastObjId = objinfo->GetObjId();
   }

   return SqlReadObjectDirect(obj, cl, objid);
}

//______________________________________________________________________________
Bool_t TBufferSQL2::SqlObjectInfo(Long64_t objid, TString& clname, Version_t& version)
{
// Returns object info like classname and version
// Should be taken from buffer, which is produced in the begginnig

   if ((objid<0) || (fObjectsInfos==0)) return kFALSE;

 //  if (fObjectsInfos==0) return fSQL->SQLObjectInfo(objid, clname, version);

   // suppose that objects info are sorted out

   Long64_t shift = objid - fFirstObjId;

   TSQLObjectInfo* info = 0;
   if ((shift>=0) && (shift<=fObjectsInfos->GetLast())) {
      info = (TSQLObjectInfo*) fObjectsInfos->At(shift);
      if (info->GetObjId()!=objid) info = 0;
   }

   if (info==0) {
      // I hope, i will never get inside it
      Info("SqlObjectInfo", "Standard not works %lld", objid);
      for (Int_t n=0;n<=fObjectsInfos->GetLast();n++) {
         info = (TSQLObjectInfo*) fObjectsInfos->At(n);
         if (info->GetObjId()==objid) break;
         info = 0;
      }
   }

   if (info==0) return kFALSE;

   clname = info->GetObjClassName();
   version = info->GetObjVersion();
   return kTRUE;
}


//______________________________________________________________________________
TSQLObjectData* TBufferSQL2::SqlObjectData(Long64_t objid, TSQLClassInfo* sqlinfo)
{
   // creates TSQLObjectData for specifed object id and specified class
   // Object data for each class can be stored in two different tables.
   // First table contains data in column-wise form for simple types like integer,
   // strings and so on when second table contains any other data which cannot
   // be converted into column-wise representation.
   // TSQLObjectData will contain results of the requests to both such tables for
   // concrete object id.

   TSQLResult *classdata = 0;
   TSQLRow *classrow = 0;

   if (sqlinfo->IsClassTableExist()) {

      TSQLObjectDataPool* pool = 0;

      if (fPoolsMap!=0)
        pool = (TSQLObjectDataPool*) fPoolsMap->GetValue(sqlinfo);

      if ((pool==0) && (fLastObjId>=fFirstObjId)) {
         if (gDebug>4) Info("SqlObjectData","Before request to %s",sqlinfo->GetClassTableName());
         TSQLResult *alldata = fSQL->GetNormalClassDataAll(fFirstObjId, fLastObjId, sqlinfo);
         if (gDebug>4) Info("SqlObjectData","After request res = 0x%lx",(Long_t)alldata);
         if (alldata==0) {
            Error("SqlObjectData","Cannot get data from table %s",sqlinfo->GetClassTableName());
            return 0;
         }

         if (fPoolsMap==0) fPoolsMap = new TMap();
         pool = new TSQLObjectDataPool(sqlinfo, alldata);
         fPoolsMap->Add(sqlinfo, pool);
      }

      if (pool==0) return 0;

      if (pool->GetSqlInfo()!=sqlinfo) {
         Error("SqlObjectData","Missmatch in pools map !!! CANNOT BE !!!");
         return 0;
      }

      classdata = pool->GetClassData();

      classrow = pool->GetObjectRow(objid);
      if (classrow==0) {
         Error("SqlObjectData","Can not find row for objid = %lld in table %s", objid, sqlinfo->GetClassTableName());
         return 0;
      }
   }

   TSQLResult *blobdata = 0;
   TSQLStatement* blobstmt = fSQL->GetBlobClassDataStmt(objid, sqlinfo);

   if (blobstmt==0) blobdata = fSQL->GetBlobClassData(objid, sqlinfo);

   return new TSQLObjectData(sqlinfo, objid, classdata, classrow, blobdata, blobstmt);
}

//______________________________________________________________________________
void TBufferSQL2::WriteObject(const TObject *obj)
{
   // Convert object into sql structures.
   // !!! Should be used only by TBufferSQL2 itself.
   // Use SqlWrite() functions to convert your object to sql
   // Redefined here to avoid gcc 3.x warning

   TBufferFile::WriteObject(obj);
}

//______________________________________________________________________________
Int_t TBufferSQL2::SqlWriteObject(const void* obj, const TClass* cl, TMemberStreamer *streamer, Int_t streamer_index)
{
   // Write object to buffer
   // If object was written before, only pointer will be stored
   // Return id of saved object

   if (gDebug>1)
      std::cout << " SqlWriteObject " << obj << " : cl = " << (cl ? cl->GetName() : "null") << std::endl;

   PushStack();

   Long64_t objid = -1;

   if (cl==0) obj = 0;

   if (obj==0)
      objid = 0;
   else
   if (fObjMap!=0) {
      ULong_t hash = TString::Hash(&obj, sizeof(void*));
      Long_t value = fObjMap->GetValue(hash, (Long_t) obj);
      if (value>0)
         objid = fFirstObjId + value - 1;
   }

   if (gDebug>1)
      std::cout << "    Find objectid = " << objid << std::endl;

   if (objid>=0) {
      Stack()->SetObjectPointer(objid);
      PopStack();
      return objid;
   }

   objid = fObjIdCounter++;

   Stack()->SetObjectRef(objid, cl);

   ULong_t hash = TString::Hash(&obj, sizeof(void*));
   if (fObjMap==0) fObjMap = new TExMap();
   if (fObjMap->GetValue(hash, (Long_t) obj)==0)
      fObjMap->Add(hash, (Long_t) obj, (Long_t) objid - fFirstObjId + 1);

   if (streamer!=0)
      (*streamer)(*this, (void*) obj, streamer_index);
   else
      ((TClass*)cl)->Streamer((void*)obj, *this);

   if (gDebug>1)
      std::cout << "Done write of " << cl->GetName() << std::endl;

   PopStack();

   return objid;
}

//______________________________________________________________________________
void* TBufferSQL2::SqlReadObject(void* obj, TClass** cl, TMemberStreamer *streamer, Int_t streamer_index, const TClass *onFileClass)
{
   // Read object from the buffer

   if (cl) *cl = 0;

   if (fErrorFlag>0) return obj;

   Bool_t findptr = kFALSE;

   const char* refid = fCurrentData->GetValue();
   if ((refid==0) || (strlen(refid)==0)) {
      Error("SqlReadObject","Invalid object reference value");
      fErrorFlag = 1;
      return obj;
   }

   Long64_t objid = -1;
   sscanf(refid, FLong64, &objid);

   if (gDebug>2)
      Info("SqlReadObject","Starting objid = %lld column=%s", objid, fCurrentData->GetLocatedField());

   if (!fCurrentData->IsBlobData() ||
       fCurrentData->VerifyDataType(sqlio::ObjectPtr,kFALSE)) {
      if (objid==0) {
         obj = 0;
         findptr = kTRUE;
      } else {
         if (objid==-1) {
            findptr = kTRUE;
         } else {
            if ((fObjMap!=0) && (objid>=fFirstObjId)) {
               void* obj1 = (void*) (Long_t)fObjMap->GetValue((Long_t) objid - fFirstObjId);
               if (obj1!=0) {
                  obj = obj1;
                  findptr = kTRUE;
                  TString clname;
                  Version_t version;
                  if ((cl!=0) && SqlObjectInfo(objid, clname, version))
                     *cl = TClass::GetClass(clname);
               }
            }
         }
      }
   }

   if ((gDebug>3) && findptr)
      std::cout << "    Found pointer " << (obj ? obj : 0)
           << " class = " << ((cl && *cl) ? (*cl)->GetName() : "null") << std::endl;

   if (findptr) {
      fCurrentData->ShiftToNextValue();
      return obj;
   }

   if (fCurrentData->IsBlobData())
      if (!fCurrentData->VerifyDataType(sqlio::ObjectRef)) {
         Error("SqlReadObject","Object reference or pointer is not found in blob data");
         fErrorFlag = 1;
         return obj;
      }

   fCurrentData->ShiftToNextValue();

   if ((gDebug>2) || (objid<0))
      std::cout << "Found object reference " << objid << std::endl;

   return SqlReadObjectDirect(obj, cl, objid, streamer, streamer_index, onFileClass);
}

//______________________________________________________________________________
void* TBufferSQL2::SqlReadObjectDirect(void* obj, TClass** cl, Long64_t objid, TMemberStreamer *streamer, Int_t streamer_index, const TClass *onFileClass)
{
   // Read object data.
   // Class name and version are taken from special objects table.

   TString clname;
   Version_t version;

   if (!SqlObjectInfo(objid, clname, version)) return obj;

   if (gDebug>2)
      Info("SqlReadObjectDirect","objid = %lld clname = %s ver = %d",objid, clname.Data(), version);

   TSQLClassInfo* sqlinfo = fSQL->FindSQLClassInfo(clname.Data(), version);

   TClass* objClass = TClass::GetClass(clname);
   if (objClass == TDirectory::Class()) objClass = TDirectoryFile::Class();

   if ((objClass==0) || (sqlinfo==0)) {
      Error("SqlReadObjectDirect","Class %s is not known", clname.Data());
      return obj;
   }

   if (obj==0) obj = objClass->New();

   if (fObjMap==0) fObjMap = new TExMap();

   fObjMap->Add((Long_t) objid - fFirstObjId, (Long_t) obj);

   PushStack()->SetObjectRef(objid, objClass);

   TSQLObjectData* olddata = fCurrentData;

   if (sqlinfo->IsClassTableExist()) {
      // TObject and TString classes treated differently
      if ((objClass==TObject::Class()) || (objClass==TString::Class())) {

         TSQLObjectData* objdata = new TSQLObjectData;
         if (objClass==TObject::Class())
            TSQLStructure::UnpackTObject(fSQL, this, objdata, objid, version);
         else
            if (objClass==TString::Class())
               TSQLStructure::UnpackTString(fSQL, this, objdata, objid, version);

         Stack()->AddObjectData(objdata);
         fCurrentData = objdata;
      } else
         // before normal streamer first version will be read and
         // then streamer functions of TStreamerInfo class
         fReadVersionBuffer = version;
   } else {
      TSQLObjectData* objdata = SqlObjectData(objid, sqlinfo);
      if ((objdata==0) || !objdata->PrepareForRawData()) {
         Error("SqlReadObjectDirect","No found raw data for obj %lld in class %s version %d table", objid, clname.Data(), version);
         fErrorFlag = 1;
         return obj;
      }

      Stack()->AddObjectData(objdata);

      fCurrentData = objdata;
   }

   if (streamer!=0) {
      streamer->SetOnFileClass( onFileClass );
      (*streamer)(*this, (void*)obj, streamer_index);
   } else {
      objClass->Streamer((void*)obj, *this, onFileClass);
   }

   PopStack();

   if (gDebug>1)
      std::cout << "Read object of class " << objClass->GetName() << " done" << std::endl << std::endl;

   if (cl!=0) *cl = objClass;

   fCurrentData = olddata;

   return obj;
}

//______________________________________________________________________________
void  TBufferSQL2::IncrementLevel(TVirtualStreamerInfo* info)
{
   // Function is called from TStreamerInfo WriteBuffer and Readbuffer functions
   // and indent new level in data structure.
   // This call indicates, that TStreamerInfo functions starts streaming
   // object data of correspondent class

   if (info==0) return;

   PushStack()->SetStreamerInfo((TStreamerInfo*)info);

   if (gDebug>2)
      std::cout << " IncrementLevel " << info->GetName() << std::endl;

   WorkWithClass(info->GetName(), info->GetClassVersion());
}

//______________________________________________________________________________
void  TBufferSQL2::DecrementLevel(TVirtualStreamerInfo* info)
{
   // Function is called from TStreamerInfo WriteBuffer and Readbuffer functions
   // and decrease level in sql structure.

   TSQLStructure* curr = Stack();
   if (curr->GetElement()) PopStack(); // for element
   PopStack();  // for streamerinfo

   // restore value of object data
   fCurrentData = Stack()->GetObjectData(kTRUE);

   fExpectedChain = kFALSE;

   if (gDebug>2)
      std::cout << " DecrementLevel " << info->GetClass()->GetName() << std::endl;
}

//______________________________________________________________________________
void TBufferSQL2::SetStreamerElementNumber(TStreamerElement *elem, Int_t comp_type)
{
   // Function is called from TStreamerInfo WriteBuffer and Readbuffer functions
   // and add/verify next element in sql tables
   // This calls allows separate data, correspondent to one class member, from another

   if (Stack()->GetElement()) PopStack(); // was with if (number > 0), i.e. not first element.
   TSQLStructure* curr = Stack();

   TStreamerInfo* info = curr->GetStreamerInfo();
   if (info==0) {
      Error("SetStreamerElementNumber","Error in structures stack");
      return;
   }

   Int_t elem_type = elem->GetType();

   fExpectedChain = ((elem_type>0) && (elem_type<20)) &&
      (comp_type - elem_type == TStreamerInfo::kOffsetL);

   WorkWithElement(elem, comp_type);
}

//______________________________________________________________________________
void TBufferSQL2::ClassBegin(const TClass* cl, Version_t classversion)
{
   // This method inform buffer data of which class now
   // will be streamed. When reading, classversion should be specified
   // as was read by TBuffer::ReadVersion() call
   //
   // ClassBegin(), ClassEnd() & ClassMemeber() should be used in
   // custom class streamers to specify which kind of data are
   // now streamed to/from buffer. That information is used to correctly
   // convert class data to/from "normal" sql tables with meaningfull names
   // and correct datatypes. Without that functions data from custom streamer
   // will be saved as "raw" data in special _streamer_ table one value after another
   // Such MUST be used when object is written with standard ROOT streaming
   // procedure, but should be read back in custom streamer.
   // For example, custom streamer of TNamed class may look like:

// void TNamed::Streamer(TBuffer &b)
//   UInt_t R__s, R__c;
//   if (b.IsReading()) {
//      Version_t R__v = b.ReadVersion(&R__s, &R__c);
//      b.ClassBegin(TNamed::Class(), R__v);
//      b.ClassMember("TObject");
//      TObject::Streamer(b);
//      b.ClassMember("fName","TString");
//      fName.Streamer(b);
//      b.ClassMember("fTitle","TString");
//      fTitle.Streamer(b);
//      b.ClassEnd(TNamed::Class());
//      b.SetBufferOffset(R__s+R__c+sizeof(UInt_t));
//   } else {
//      TNamed::Class()->WriteBuffer(b,this);
//   }

   if (classversion<0) classversion = cl->GetClassVersion();

   PushStack()->SetCustomClass(cl, classversion);

   if (gDebug>2) Info("ClassBegin", "%s", cl->GetName());

   WorkWithClass(cl->GetName(), classversion);
}

//______________________________________________________________________________
void TBufferSQL2::ClassEnd(const TClass* cl)
{
   // Method indicates end of streaming of classdata in custom streamer.
   // See ClassBegin() method for more details.

   TSQLStructure* curr = Stack();
   if (curr->GetType()==TSQLStructure::kSqlCustomElement) PopStack(); // for element
   PopStack();  // for streamerinfo

   // restore value of object data
   fCurrentData = Stack()->GetObjectData(kTRUE);

   fExpectedChain = kFALSE;

   if (gDebug>2) Info("ClassEnd","%s",cl->GetName());
}

//______________________________________________________________________________
void TBufferSQL2::ClassMember(const char* name, const char* typeName, Int_t arrsize1, Int_t arrsize2)
{
   // Method indicates name and typename of class memeber,
   // which should be now streamed in custom streamer
   // Following combinations are supported:
   // 1. name = "ClassName", typeName = 0 or typename==ClassName
   //    This is a case, when data of parent class "ClassName" should be streamed.
   //    For instance, if class directly inherited from TObject, custom
   //    streamer should include following code:
   //    b.ClassMember("TObject");
   //    TObject::Streamer(b);
   // 2. Basic data type
   //      b.ClassMember("fInt","Int_t");
   //      b >> fInt;
   // 3. Array of basic data types
   //      b.ClassMember("fArr","Int_t", 5);
   //      b.ReadFastArray(fArr, 5);
   // 4. Object as data member
   //      b.ClassMemeber("fName","TString");
   //      fName.Streamer(b);
   // 5. Pointer on object as datamember
   //      b.ClassMemeber("fObj","TObject*");
   //      b.StreamObject(b);
   // arrsize1 and arrsize2 arguments (when specified) indicate first and
   // second dimension of array. Can be used for array of basic types.
   // For more details see ClassBegin() method description.

   if (typeName==0) typeName = name;

   if ((name==0) || (strlen(name)==0)) {
      Error("ClassMember","Invalid member name");
      fErrorFlag = 1;
      return;
   }

   TString tname = typeName;

   Int_t typ_id = -1;

   if (strcmp(typeName,"raw:data")==0)
      typ_id = TStreamerInfo::kMissing;

   if (typ_id<0) {
      TDataType *dt = gROOT->GetType(typeName);
      if (dt!=0)
         if ((dt->GetType()>0) && (dt->GetType()<20))
            typ_id = dt->GetType();
   }

   if (typ_id<0)
      if (strcmp(name, typeName)==0) {
         TClass* cl = TClass::GetClass(tname.Data());
         if (cl!=0) typ_id = TStreamerInfo::kBase;
      }

   if (typ_id<0) {
      Bool_t isptr = kFALSE;
      if (tname[tname.Length()-1]=='*') {
         tname.Resize(tname.Length()-1);
         isptr = kTRUE;
      }
      TClass* cl = TClass::GetClass(tname.Data());
      if (cl==0) {
         Error("ClassMember","Invalid class specifier %s", typeName);
         fErrorFlag = 1;
         return;
      }

      if (cl->IsTObject())
         typ_id = isptr ? TStreamerInfo::kObjectp : TStreamerInfo::kObject;
      else
         typ_id = isptr ? TStreamerInfo::kAnyp : TStreamerInfo::kAny;

      if ((cl==TString::Class()) && !isptr)
         typ_id = TStreamerInfo::kTString;
   }

   TStreamerElement* elem = 0;

   if (typ_id == TStreamerInfo::kMissing) {
      elem = new TStreamerElement(name,"title",0, typ_id, "raw:data");
   } else

   if (typ_id==TStreamerInfo::kBase) {
      TClass* cl = TClass::GetClass(tname.Data());
      if (cl!=0) {
         TStreamerBase* b = new TStreamerBase(tname.Data(), "title", 0);
         b->SetBaseVersion(cl->GetClassVersion());
         elem = b;
      }
   } else

   if ((typ_id>0) && (typ_id<20)) {
      elem = new TStreamerBasicType(name, "title", 0, typ_id, typeName);
   } else

   if ((typ_id==TStreamerInfo::kObject) ||
       (typ_id==TStreamerInfo::kTObject) ||
       (typ_id==TStreamerInfo::kTNamed)) {
      elem = new TStreamerObject(name, "title", 0, tname.Data());
   } else

   if (typ_id==TStreamerInfo::kObjectp) {
      elem = new TStreamerObjectPointer(name, "title", 0, tname.Data());
   } else

   if (typ_id==TStreamerInfo::kAny) {
      elem = new TStreamerObjectAny(name, "title", 0, tname.Data());
   } else

   if (typ_id==TStreamerInfo::kAnyp) {
      elem = new TStreamerObjectAnyPointer(name, "title", 0, tname.Data());
   } else

   if (typ_id==TStreamerInfo::kTString) {
      elem = new TStreamerString(name, "title", 0);
   }

   if (elem==0) {
      Error("ClassMember","Invalid combination name = %s type = %s", name, typeName);
      fErrorFlag = 1;
      return;
   }

   if (arrsize1>0) {
      elem->SetArrayDim(arrsize2>0 ? 2 : 1);
      elem->SetMaxIndex(0, arrsize1);
      if (arrsize2>0)
         elem->SetMaxIndex(1, arrsize2);
   }

   // return stack to CustomClass node
   if (Stack()->GetType()==TSQLStructure::kSqlCustomElement) PopStack();

   fExpectedChain = kFALSE;

   // we indicate that there is no streamerinfo
   WorkWithElement(elem, -1);
}

//______________________________________________________________________________
void TBufferSQL2::WorkWithClass(const char* classname, Version_t classversion)
{
   // This function is a part of IncrementLevel method.
   // Also used in StartClass method

   fExpectedChain = kFALSE;

   if (IsReading()) {
      Long64_t objid = 0;

//      if ((fCurrentData!=0) && fCurrentData->VerifyDataType(sqlio::ObjectInst, kFALSE))
//        if (!fCurrentData->IsBlobData()) Info("WorkWithClass","Big problem %s", fCurrentData->GetValue());

      if ((fCurrentData!=0) && fCurrentData->IsBlobData() &&
          fCurrentData->VerifyDataType(sqlio::ObjectInst, kFALSE)) {
         objid = atoi(fCurrentData->GetValue());
         fCurrentData->ShiftToNextValue();
         TString sobjid;
         sobjid.Form("%lld",objid);
         Stack()->ChangeValueOnly(sobjid.Data());
      } else
         objid = Stack()->DefineObjectId(kTRUE);
      if (objid<0) {
         Error("WorkWithClass","cannot define object id");
         fErrorFlag = 1;
         return;
      }

      TSQLClassInfo* sqlinfo = fSQL->FindSQLClassInfo(classname, classversion);
      if (sqlinfo==0) {
         Error("WorkWithClass","Can not find table for class %s version %d", classname, classversion);
         fErrorFlag = 1;
         return;
      }

      TSQLObjectData* objdata = SqlObjectData(objid, sqlinfo);
      if (objdata==0) {
         Error("WorkWithClass","Request error for data of object %lld for class %s version %d", objid, classname, classversion);
         fErrorFlag = 1;
         return;
      }

      Stack()->AddObjectData(objdata);

      fCurrentData = objdata;
   }
}

//______________________________________________________________________________
void TBufferSQL2::WorkWithElement(TStreamerElement* elem, Int_t /* comp_type */)
{
   // This function is a part of SetStreamerElementNumber method.
   // It is introduced for reading of data for specified data memeber of class.
   // Used also in ReadFastArray methods to resolve problem of compressed data,
   // when several data memebers of the same basic type streamed with single ...FastArray call

   if (gDebug>2)
      Info("WorkWithElement","elem = %s",elem->GetName());

   TSQLStructure* stack = Stack(1);
   TStreamerInfo* info = stack->GetStreamerInfo();
   Int_t number = info ? info->GetElements()->IndexOf(elem) : -1;

   if (number>=0)
      PushStack()->SetStreamerElement(elem, number);
   else
      PushStack()->SetCustomElement(elem);

   if (IsReading()) {

      if (fCurrentData==0) {
         Error("WorkWithElement","Object data is lost");
         fErrorFlag = 1;
         return;
      }

      fCurrentData = Stack()->GetObjectData(kTRUE);

      Int_t located = Stack()->LocateElementColumn(fSQL, this, fCurrentData);

      if (located==TSQLStructure::kColUnknown) {
         Error("WorkWithElement","Cannot locate correct column in the table");
         fErrorFlag = 1;
         return;
      } else
         if ((located==TSQLStructure::kColObject) ||
             (located==TSQLStructure::kColObjectArray) ||
             (located==TSQLStructure::kColParent)) {
            // search again for object data while for BLOB it should be already assign
            fCurrentData = Stack()->GetObjectData(kTRUE);
         }
   }
}

//______________________________________________________________________________
TClass* TBufferSQL2::ReadClass(const TClass*, UInt_t*)
{
   // suppressed function of TBuffer

   return 0;
}

//______________________________________________________________________________
void TBufferSQL2::WriteClass(const TClass*)
{
   // suppressed function of TBuffer
}

//______________________________________________________________________________
Int_t TBufferSQL2::CheckByteCount(UInt_t /*r_s */, UInt_t /*r_c*/, const TClass* /*cl*/)
{
   // suppressed function of TBuffer

   return 0;
}

//______________________________________________________________________________
Int_t  TBufferSQL2::CheckByteCount(UInt_t, UInt_t, const char*)
{
   // suppressed function of TBuffer

   return 0;
}

//______________________________________________________________________________
void TBufferSQL2::SetByteCount(UInt_t, Bool_t)
{
   // suppressed function of TBuffer
}

//______________________________________________________________________________
void TBufferSQL2::SkipVersion(const TClass *cl)
{
   // Skip class version from I/O buffer.
   ReadVersion(0,0,cl);
}

//______________________________________________________________________________
Version_t TBufferSQL2::ReadVersion(UInt_t *start, UInt_t *bcnt, const TClass *)
{
   // read version value from buffer
   // actually version is normally defined by table name
   // and kept in intermediate variable fReadVersionBuffer

   Version_t res = 0;

   if (start) *start = 0;
   if (bcnt) *bcnt = 0;

   if (fReadVersionBuffer>=0) {
      res = fReadVersionBuffer;
      fReadVersionBuffer = -1;
      if (gDebug>3)
         std::cout << "TBufferSQL2::ReadVersion from buffer = " << res << std::endl;
   } else
   if ((fCurrentData!=0) && fCurrentData->IsBlobData() &&
       fCurrentData->VerifyDataType(sqlio::Version)) {
      TString value = fCurrentData->GetValue();
      res = value.Atoi();
      if (gDebug>3)
         std::cout << "TBufferSQL2::ReadVersion from blob " << fCurrentData->GetBlobPrefixName() << " = " << res << std::endl;
      fCurrentData->ShiftToNextValue();
   } else {
      Error("ReadVersion", "No correspondent tags to read version");
      fErrorFlag = 1;
   }

   return res;
}

//______________________________________________________________________________
UInt_t TBufferSQL2::WriteVersion(const TClass *cl, Bool_t /* useBcnt */)
{
   // Copies class version to buffer, but not writes it to sql immidiately
   // Version will be used to produce complete table
   // name, which will include class version

   if (gDebug>2)
      std::cout << "TBufferSQL2::WriteVersion " << (cl ? cl->GetName() : "null") << "   ver = " << (cl ? cl->GetClassVersion() : 0) << std::endl;

   if (cl)
      Stack()->AddVersion(cl);

   return 0;
}

//______________________________________________________________________________
void* TBufferSQL2::ReadObjectAny(const TClass*)
{
   // Read object from buffer. Only used from TBuffer.

   return SqlReadObject(0);
}

//______________________________________________________________________________
void TBufferSQL2::SkipObjectAny()
{
   // ?????? Skip any kind of object from buffer
   // !!!!!! fix me, not yet implemented
   // Should be just skip of current column later
}

//______________________________________________________________________________
void TBufferSQL2::WriteObjectClass(const void *actualObjStart, const TClass *actualClass)
{
   // Write object to buffer. Only used from TBuffer

   if (gDebug>2)
      std::cout << "TBufferSQL2::WriteObject of class " << (actualClass ? actualClass->GetName() : " null") << std::endl;
   SqlWriteObject(actualObjStart, actualClass);
}

#define SQLReadArrayUncompress(vname, arrsize)  \
   {                                            \
      while(indx<arrsize)                       \
         SqlReadBasic(vname[indx++]);           \
   }


#define SQLReadArrayCompress(vname, arrsize)                            \
   {                                                                    \
      while(indx<arrsize) {                                             \
         const char* name = fCurrentData->GetBlobPrefixName();          \
         Int_t first, last, res;                                        \
         if (strstr(name,sqlio::IndexSepar)==0) {                       \
            res = sscanf(name,"[%d", &first); last = first;             \
         } else res = sscanf(name,"[%d..%d", &first, &last);            \
         if (gDebug>5) std::cout << name << " first = " << first << " last = " << last << " res = " << res << std::endl; \
         if ((first!=indx) || (last<first) || (last>=arrsize)) {        \
            Error("SQLReadArrayCompress","Error reading array content %s", name); \
            fErrorFlag = 1;                                             \
            break;                                                      \
         }                                                              \
         SqlReadBasic(vname[indx]); indx++;                             \
         while(indx<=last)                                              \
            vname[indx++] = vname[first];                               \
      }                                                                 \
   }


// macro to read content of array with compression
#define SQLReadArrayContent(vname, arrsize, withsize)                   \
   {                                                                    \
      if (gDebug>3) std::cout << "SQLReadArrayContent  " << (arrsize) << std::endl; \
      PushStack()->SetArray(withsize ? arrsize : -1);                   \
      Int_t indx = 0;                                                   \
      if (fCurrentData->IsBlobData())                                   \
         SQLReadArrayCompress(vname, arrsize)                           \
         else                                                           \
            SQLReadArrayUncompress(vname, arrsize)                      \
               PopStack();                                              \
      if (gDebug>3) std::cout << "SQLReadArrayContent done " << std::endl;        \
   }

// macro to read array, which include size attribute
#define TBufferSQL2_ReadArray(tname, vname)     \
   {                                            \
      Int_t n = SqlReadArraySize();             \
      if (n<=0) return 0;                       \
      if (!vname) vname = new tname[n];         \
      SQLReadArrayContent(vname, n, kTRUE);     \
      return n;                                 \
   }

//______________________________________________________________________________
void TBufferSQL2::ReadFloat16 (Float_t *f, TStreamerElement * /*ele*/)
{
   // Read Float16 value

   SqlReadBasic(*f);
}

//______________________________________________________________________________
void TBufferSQL2::ReadDouble32 (Double_t *d, TStreamerElement * /*ele*/)
{
   // Read Double32 value

   SqlReadBasic(*d);
}

//______________________________________________________________________________
void TBufferSQL2::ReadWithFactor(Float_t *ptr, Double_t /* factor */, Double_t /* minvalue */)
{
   // Read a Double32_t from the buffer when the factor and minimun value have been specified
   // see comments about Double32_t encoding at TBufferFile::WriteDouble32().
   // Currently TBufferXML does not optimize space in this case.

   SqlReadBasic(*ptr);
}

//______________________________________________________________________________
void TBufferSQL2::ReadWithNbits(Float_t *ptr, Int_t /* nbits */)
{
   // Read a Float16_t from the buffer when the number of bits is specified (explicitly or not)
   // see comments about Float16_t encoding at TBufferFile::WriteFloat16().
   // Currently TBufferXML does not optimize space in this case.

   SqlReadBasic(*ptr);
}

//______________________________________________________________________________
void TBufferSQL2::ReadWithFactor(Double_t *ptr, Double_t /* factor */, Double_t /* minvalue */)
{
   // Read a Double32_t from the buffer when the factor and minimun value have been specified
   // see comments about Double32_t encoding at TBufferFile::WriteDouble32().
   // Currently TBufferXML does not optimize space in this case.

   SqlReadBasic(*ptr);
}

//______________________________________________________________________________
void TBufferSQL2::ReadWithNbits(Double_t *ptr, Int_t /* nbits */)
{
   // Read a Double32_t from the buffer when the number of bits is specified (explicitly or not)
   // see comments about Double32_t encoding at TBufferFile::WriteDouble32().
   // Currently TBufferXML does not optimize space in this case.

   SqlReadBasic(*ptr);
}

//______________________________________________________________________________
void TBufferSQL2::WriteFloat16 (Float_t *f, TStreamerElement * /*ele*/)
{
   // Write Float16 value

   SqlWriteBasic(*f);
}

//______________________________________________________________________________
void TBufferSQL2::WriteDouble32 (Double_t *d, TStreamerElement * /*ele*/)
{
   // Write Double32 value

   SqlWriteBasic(*d);
}

//______________________________________________________________________________
Int_t TBufferSQL2::ReadArray(Bool_t    *&b)
{
   // Read array of Bool_t from buffer

   TBufferSQL2_ReadArray(Bool_t,b);
}

//______________________________________________________________________________
Int_t TBufferSQL2::ReadArray(Char_t    *&c)
{
   // Read array of Char_t from buffer

   TBufferSQL2_ReadArray(Char_t,c);
}

//______________________________________________________________________________
Int_t TBufferSQL2::ReadArray(UChar_t   *&c)
{
   // Read array of UChar_t from buffer

   TBufferSQL2_ReadArray(UChar_t,c);
}

//______________________________________________________________________________
Int_t TBufferSQL2::ReadArray(Short_t   *&h)
{
   // Read array of Short_t from buffer

   TBufferSQL2_ReadArray(Short_t,h);
}

//______________________________________________________________________________
Int_t TBufferSQL2::ReadArray(UShort_t  *&h)
{
   // Read array of UShort_t from buffer

   TBufferSQL2_ReadArray(UShort_t,h);
}

//______________________________________________________________________________
Int_t TBufferSQL2::ReadArray(Int_t     *&i)
{
   // Read array of Int_t from buffer

   TBufferSQL2_ReadArray(Int_t,i);
}

//______________________________________________________________________________
Int_t TBufferSQL2::ReadArray(UInt_t    *&i)
{
   // Read array of UInt_t from buffer

   TBufferSQL2_ReadArray(UInt_t,i);
}

//______________________________________________________________________________
Int_t TBufferSQL2::ReadArray(Long_t    *&l)
{
   // Read array of Long_t from buffer

   TBufferSQL2_ReadArray(Long_t,l);
}

//______________________________________________________________________________
Int_t TBufferSQL2::ReadArray(ULong_t   *&l)
{
   // Read array of ULong_t from buffer

   TBufferSQL2_ReadArray(ULong_t,l);
}

//______________________________________________________________________________
Int_t TBufferSQL2::ReadArray(Long64_t  *&l)
{
   // Read array of Long64_t from buffer

   TBufferSQL2_ReadArray(Long64_t,l);
}

//______________________________________________________________________________
Int_t TBufferSQL2::ReadArray(ULong64_t *&l)
{
   // Read array of ULong64_t from buffer

   TBufferSQL2_ReadArray(ULong64_t,l);
}

//______________________________________________________________________________
Int_t TBufferSQL2::ReadArray(Float_t   *&f)
{
   // Read array of Float_t from buffer

   TBufferSQL2_ReadArray(Float_t,f);
}

//______________________________________________________________________________
Int_t TBufferSQL2::ReadArray(Double_t  *&d)
{
   // Read array of Double_t from buffer

   TBufferSQL2_ReadArray(Double_t,d);
}

//______________________________________________________________________________
Int_t TBufferSQL2::ReadArrayFloat16(Float_t  *&f, TStreamerElement * /*ele*/)
{
   // Read array of Float16_t from buffer

   TBufferSQL2_ReadArray(Float_t,f);
}

//______________________________________________________________________________
Int_t TBufferSQL2::ReadArrayDouble32(Double_t  *&d, TStreamerElement * /*ele*/)
{
   // Read array of Double32_t from buffer

   TBufferSQL2_ReadArray(Double_t,d);
}

// macro to read static array, which include size attribute
#define TBufferSQL2_ReadStaticArray(vname)      \
   {                                            \
      Int_t n = SqlReadArraySize();             \
      if (n<=0) return 0;                       \
      if (!vname) return 0;                     \
      SQLReadArrayContent(vname, n, kTRUE);     \
      return n;                                 \
   }

//______________________________________________________________________________
Int_t TBufferSQL2::ReadStaticArray(Bool_t    *b)
{
   // Read array of Bool_t from buffer

   TBufferSQL2_ReadStaticArray(b);
}

//______________________________________________________________________________
Int_t TBufferSQL2::ReadStaticArray(Char_t    *c)
{
   // Read array of Char_t from buffer

   TBufferSQL2_ReadStaticArray(c);
}

//______________________________________________________________________________
Int_t TBufferSQL2::ReadStaticArray(UChar_t   *c)
{
   // Read array of UChar_t from buffer

   TBufferSQL2_ReadStaticArray(c);
}

//______________________________________________________________________________
Int_t TBufferSQL2::ReadStaticArray(Short_t   *h)
{
   // Read array of Short_t from buffer

   TBufferSQL2_ReadStaticArray(h);
}

//______________________________________________________________________________
Int_t TBufferSQL2::ReadStaticArray(UShort_t  *h)
{
   // Read array of UShort_t from buffer

   TBufferSQL2_ReadStaticArray(h);
}

//______________________________________________________________________________
Int_t TBufferSQL2::ReadStaticArray(Int_t     *i)
{
   // Read array of Int_t from buffer

   TBufferSQL2_ReadStaticArray(i);
}

//______________________________________________________________________________
Int_t TBufferSQL2::ReadStaticArray(UInt_t    *i)
{
   // Read array of UInt_t from buffer

   TBufferSQL2_ReadStaticArray(i);
}

//______________________________________________________________________________
Int_t TBufferSQL2::ReadStaticArray(Long_t    *l)
{
   // Read array of Long_t from buffer

   TBufferSQL2_ReadStaticArray(l);
}

//______________________________________________________________________________
Int_t TBufferSQL2::ReadStaticArray(ULong_t   *l)
{
   // Read array of ULong_t from buffer

   TBufferSQL2_ReadStaticArray(l);
}

//______________________________________________________________________________
Int_t TBufferSQL2::ReadStaticArray(Long64_t  *l)
{
   // Read array of Long64_t from buffer

   TBufferSQL2_ReadStaticArray(l);
}

//______________________________________________________________________________
Int_t TBufferSQL2::ReadStaticArray(ULong64_t *l)
{
   // Read array of ULong64_t from buffer

   TBufferSQL2_ReadStaticArray(l);
}

//______________________________________________________________________________
Int_t TBufferSQL2::ReadStaticArray(Float_t   *f)
{
   // Read array of Float_t from buffer

   TBufferSQL2_ReadStaticArray(f);
}

//______________________________________________________________________________
Int_t TBufferSQL2::ReadStaticArray(Double_t  *d)
{
   // Read array of Double_t from buffer

   TBufferSQL2_ReadStaticArray(d);
}

//______________________________________________________________________________
Int_t TBufferSQL2::ReadStaticArrayFloat16(Float_t  *f, TStreamerElement * /*ele*/)
{
   // Read array of Float16_t from buffer

   TBufferSQL2_ReadStaticArray(f);
}

//______________________________________________________________________________
Int_t TBufferSQL2::ReadStaticArrayDouble32(Double_t  *d, TStreamerElement * /*ele*/)
{
   // Read array of Double32_t from buffer

   TBufferSQL2_ReadStaticArray(d);
}

// macro to read content of array, which not include size of array
// macro also treat situation, when instead of one single array chain of several elements should be produced
#define TBufferSQL2_ReadFastArray(vname)                                \
   {                                                                    \
      if (n<=0) return;                                                 \
      TStreamerElement* elem = Stack(0)->GetElement();                  \
      if ((elem!=0) && (elem->GetType()>TStreamerInfo::kOffsetL) &&     \
          (elem->GetType()<TStreamerInfo::kOffsetP) &&                  \
          (elem->GetArrayLength()!=n)) fExpectedChain = kTRUE;          \
      if (fExpectedChain) {                                             \
         fExpectedChain = kFALSE;                                       \
         Int_t startnumber = Stack(0)->GetElementNumber();              \
         TStreamerInfo* info = Stack(1)->GetStreamerInfo();             \
         Int_t index = 0;                                               \
         while (index<n) {                                              \
            elem = (TStreamerElement*)info->GetElements()->At(startnumber++); \
            if (index>1) { PopStack(); WorkWithElement(elem, elem->GetType()); } \
            if (elem->GetType()<TStreamerInfo::kOffsetL) {              \
               SqlReadBasic(vname[index]);                              \
               index++;                                                 \
            } else {                                                    \
               Int_t elemlen = elem->GetArrayLength();                  \
               SQLReadArrayContent((vname+index), elemlen, kFALSE);     \
               index+=elemlen;                                          \
            }                                                           \
         }                                                              \
      } else {                                                          \
         SQLReadArrayContent(vname, n, kFALSE);                         \
      }                                                                 \
   }
//______________________________________________________________________________
void TBufferSQL2::ReadFastArray(Bool_t    *b, Int_t n)
{
   // read array of Bool_t from buffer

   TBufferSQL2_ReadFastArray(b);
}

//______________________________________________________________________________
void TBufferSQL2::ReadFastArray(Char_t    *c, Int_t n)
{
   // read array of Char_t from buffer
   // if nodename==CharStar, read all array as string

   if ((n>0) && fCurrentData->IsBlobData() &&
       fCurrentData->VerifyDataType(sqlio::CharStar, kFALSE)) {
      const char* buf = SqlReadCharStarValue();
      if ((buf==0) || (n<=0)) return;
      Int_t size = strlen(buf);
      if (size<n) size = n;
      memcpy(c, buf, size);
   } else {
      //     std::cout << "call standard macro TBufferSQL2_ReadFastArray" << std::endl;
      TBufferSQL2_ReadFastArray(c);
   }
}

//______________________________________________________________________________
void TBufferSQL2::ReadFastArray(UChar_t   *c, Int_t n)
{
   // read array of UChar_t from buffer

   TBufferSQL2_ReadFastArray(c);
}

//______________________________________________________________________________
void TBufferSQL2::ReadFastArray(Short_t   *h, Int_t n)
{
   // read array of Short_t from buffer

   TBufferSQL2_ReadFastArray(h);
}

//______________________________________________________________________________
void TBufferSQL2::ReadFastArray(UShort_t  *h, Int_t n)
{
   // read array of UShort_t from buffer

   TBufferSQL2_ReadFastArray(h);
}

//______________________________________________________________________________
void TBufferSQL2::ReadFastArray(Int_t     *i, Int_t n)
{
   // read array of Int_t from buffer

   TBufferSQL2_ReadFastArray(i);
}

//______________________________________________________________________________
void TBufferSQL2::ReadFastArray(UInt_t    *i, Int_t n)
{
   // read array of UInt_t from buffer

   TBufferSQL2_ReadFastArray(i);
}

//______________________________________________________________________________
void TBufferSQL2::ReadFastArray(Long_t    *l, Int_t n)
{
   // read array of Long_t from buffer

   TBufferSQL2_ReadFastArray(l);
}

//______________________________________________________________________________
void TBufferSQL2::ReadFastArray(ULong_t   *l, Int_t n)
{
   // read array of ULong_t from buffer

   TBufferSQL2_ReadFastArray(l);
}

//______________________________________________________________________________
void TBufferSQL2::ReadFastArray(Long64_t  *l, Int_t n)
{
   // read array of Long64_t from buffer

   TBufferSQL2_ReadFastArray(l);
}

//______________________________________________________________________________
void TBufferSQL2::ReadFastArray(ULong64_t *l, Int_t n)
{
   // read array of ULong64_t from buffer

   TBufferSQL2_ReadFastArray(l);
}

//______________________________________________________________________________
void TBufferSQL2::ReadFastArray(Float_t   *f, Int_t n)
{
   // read array of Float_t from buffer

   TBufferSQL2_ReadFastArray(f);
}

//______________________________________________________________________________
void TBufferSQL2::ReadFastArray(Double_t  *d, Int_t n)
{
   // read array of Double_t from buffer

   TBufferSQL2_ReadFastArray(d);
}

//______________________________________________________________________________
void TBufferSQL2::ReadFastArrayFloat16(Float_t  *f, Int_t n, TStreamerElement * /*ele*/)
{
   // read array of Float16_t from buffer

   TBufferSQL2_ReadFastArray(f);
}

//______________________________________________________________________________
void TBufferSQL2::ReadFastArrayWithFactor(Float_t  *f, Int_t n, Double_t /* factor */, Double_t /* minvalue */)
{
   // read array of Float16_t from buffer

   TBufferSQL2_ReadFastArray(f);
}

//______________________________________________________________________________
void TBufferSQL2::ReadFastArrayWithNbits(Float_t  *f, Int_t n, Int_t /*nbits*/)
{
   // read array of Float16_t from buffer

   TBufferSQL2_ReadFastArray(f);
}

//______________________________________________________________________________
void TBufferSQL2::ReadFastArrayDouble32(Double_t  *d, Int_t n, TStreamerElement * /*ele*/)
{
   // read array of Double32_t from buffer

   TBufferSQL2_ReadFastArray(d);
}

//______________________________________________________________________________
void TBufferSQL2::ReadFastArrayWithFactor(Double_t  *d, Int_t n, Double_t /* factor */, Double_t /* minvalue */)
{
   // read array of Double32_t from buffer

   TBufferSQL2_ReadFastArray(d);
}
//______________________________________________________________________________
void TBufferSQL2::ReadFastArrayWithNbits(Double_t  *d, Int_t n, Int_t /*nbits*/)
{
   // read array of Double32_t from buffer

   TBufferSQL2_ReadFastArray(d);
}

//______________________________________________________________________________
void TBufferSQL2::ReadFastArray(void  *start, const TClass *cl, Int_t n, TMemberStreamer *streamer, const TClass* onFileClass )
{
   // Same functionality as TBuffer::ReadFastArray(...) but
   // instead of calling cl->Streamer(obj,buf) call here
   // buf.StreamObject(obj, cl). In that case it is easy to understand where
   // object data is started and finished

   if (gDebug>2)
      Info("ReadFastArray","(void *");

   if (streamer) {
      StreamObject(start, streamer, cl, 0, onFileClass);
//      (*streamer)(*this,start,0);
      return;
   }

   int objectSize = cl->Size();
   char *obj = (char*)start;
   char *end = obj + n*objectSize;

   for(; obj<end; obj+=objectSize) {
      StreamObject(obj, cl, onFileClass);
   }
   //   TBuffer::ReadFastArray(start, cl, n, s);
}

//______________________________________________________________________________
void TBufferSQL2::ReadFastArray(void **start, const TClass *cl, Int_t n, Bool_t isPreAlloc, TMemberStreamer *streamer, const TClass* onFileClass )
{
   // Same functionality as TBuffer::ReadFastArray(...) but
   // instead of calling cl->Streamer(obj,buf) call here
   // buf.StreamObject(obj, cl). In that case it is easy to understand where
   // object data is started and finished

   if (gDebug>2)
      Info("ReadFastArray","(void **  pre = %d  n = %d", isPreAlloc, n);

   if (streamer) {
      if (isPreAlloc) {
         for (Int_t j=0;j<n;j++) {
            if (!start[j]) start[j] = ((TClass*)cl)->New();
         }
      }
      StreamObject((void*)start, streamer, cl, 0, onFileClass);
//      (*streamer)(*this,(void*)start,0);
      return;
   }

   if (!isPreAlloc) {

      for (Int_t j=0; j<n; j++){
         //delete the object or collection
         if (start[j] && TStreamerInfo::CanDelete()) ((TClass*)cl)->Destructor(start[j],kFALSE); // call delete and desctructor
         start[j] = ReadObjectAny(cl);
      }

   } else {   //case //-> in comment

      for (Int_t j=0; j<n; j++) {
         if (!start[j]) start[j] = ((TClass*)cl)->New();
         StreamObject(start[j], cl, onFileClass);
      }
   }

   if (gDebug>2)
      Info("ReadFastArray","(void ** Done" );

   //   TBuffer::ReadFastArray(startp, cl, n, isPreAlloc, s);
}

//______________________________________________________________________________
Int_t TBufferSQL2::SqlReadArraySize()
{
   // Reads array size, written in raw data table.
   // Used in ReadArray methods, where TBuffer need to read array size first.

   const char* value = SqlReadValue(sqlio::Array);
   if ((value==0) || (strlen(value)==0)) return 0;
   Int_t sz = atoi(value);
   return sz;
}

// macro to write content of noncompressed array, not used
#define SQLWriteArrayNoncompress(vname, arrsize)        \
   {                                                    \
      for(Int_t indx=0;indx<arrsize;indx++) {           \
         SqlWriteBasic(vname[indx]);                    \
         Stack()->ChildArrayIndex(indx, 1);             \
      }                                                 \
   }

// macro to write content of compressed array
#define SQLWriteArrayCompress(vname, arrsize)                           \
   {                                                                    \
      Int_t indx = 0;                                                   \
      while(indx<arrsize) {                                             \
         Int_t curr = indx; indx++;                                     \
         while ((indx<arrsize) && (vname[indx]==vname[curr])) indx++;   \
         SqlWriteBasic(vname[curr]);                                    \
         Stack()->ChildArrayIndex(curr, indx-curr);                     \
      }                                                                 \
   }

#define SQLWriteArrayContent(vname, arrsize, withsize)  \
   {                                                    \
      PushStack()->SetArray(withsize ? arrsize : -1);   \
      if (fCompressLevel>0) {                           \
         SQLWriteArrayCompress(vname, arrsize)          \
            } else {                                    \
         SQLWriteArrayNoncompress(vname, arrsize)       \
            }                                           \
      PopStack();                                       \
   }

// macro to write array, which include size
#define TBufferSQL2_WriteArray(vname)           \
   {                                            \
      SQLWriteArrayContent(vname, n, kTRUE);    \
   }

//______________________________________________________________________________
void TBufferSQL2::WriteArray(const Bool_t    *b, Int_t n)
{
   // Write array of Bool_t to buffer

   TBufferSQL2_WriteArray(b);
}

//______________________________________________________________________________
void TBufferSQL2::WriteArray(const Char_t    *c, Int_t n)
{
   // Write array of Char_t to buffer

   TBufferSQL2_WriteArray(c);
}

//______________________________________________________________________________
void TBufferSQL2::WriteArray(const UChar_t   *c, Int_t n)
{
   // Write array of UChar_t to buffer

   TBufferSQL2_WriteArray(c);
}

//______________________________________________________________________________
void TBufferSQL2::WriteArray(const Short_t   *h, Int_t n)
{
   // Write array of Short_t to buffer

   TBufferSQL2_WriteArray(h);
}

//______________________________________________________________________________
void TBufferSQL2::WriteArray(const UShort_t  *h, Int_t n)
{
   // Write array of UShort_t to buffer

   TBufferSQL2_WriteArray(h);
}

//______________________________________________________________________________
void TBufferSQL2::WriteArray(const Int_t     *i, Int_t n)
{
   // Write array of Int_ to buffer

   TBufferSQL2_WriteArray(i);
}

//______________________________________________________________________________
void TBufferSQL2::WriteArray(const UInt_t    *i, Int_t n)
{
   // Write array of UInt_t to buffer

   TBufferSQL2_WriteArray(i);
}

//______________________________________________________________________________
void TBufferSQL2::WriteArray(const Long_t    *l, Int_t n)
{
   // Write array of Long_t to buffer

   TBufferSQL2_WriteArray(l);
}

//______________________________________________________________________________
void TBufferSQL2::WriteArray(const ULong_t   *l, Int_t n)
{
   // Write array of ULong_t to buffer

   TBufferSQL2_WriteArray(l);
}

//______________________________________________________________________________
void TBufferSQL2::WriteArray(const Long64_t  *l, Int_t n)
{
   // Write array of Long64_t to buffer

   TBufferSQL2_WriteArray(l);
}

//______________________________________________________________________________
void TBufferSQL2::WriteArray(const ULong64_t *l, Int_t n)
{
   // Write array of ULong64_t to buffer

   TBufferSQL2_WriteArray(l);
}

//______________________________________________________________________________
void TBufferSQL2::WriteArray(const Float_t   *f, Int_t n)
{
   // Write array of Float_t to buffer

   TBufferSQL2_WriteArray(f);
}

//______________________________________________________________________________
void TBufferSQL2::WriteArray(const Double_t  *d, Int_t n)
{
   // Write array of Double_t to buffer

   TBufferSQL2_WriteArray(d);
}

//______________________________________________________________________________
void TBufferSQL2::WriteArrayFloat16(const Float_t  *f, Int_t n, TStreamerElement * /*ele*/)
{
   // Write array of Float16_t to buffer

   TBufferSQL2_WriteArray(f);
}

//______________________________________________________________________________
void TBufferSQL2::WriteArrayDouble32(const Double_t  *d, Int_t n, TStreamerElement * /*ele*/)
{
   // Write array of Double32_t to buffer

   TBufferSQL2_WriteArray(d);
}

// write array without size attribute
// macro also treat situation, when instead of one single array chain of several elements should be produced
#define TBufferSQL2_WriteFastArray(vname)                               \
   {                                                                    \
      if (n<=0) return;                                                 \
      TStreamerElement* elem = Stack(0)->GetElement();                  \
      if ((elem!=0) && (elem->GetType()>TStreamerInfo::kOffsetL) &&     \
          (elem->GetType()<TStreamerInfo::kOffsetP) &&                  \
          (elem->GetArrayLength()!=n)) fExpectedChain = kTRUE;          \
      if (fExpectedChain) {                                             \
         TStreamerInfo* info = Stack(1)->GetStreamerInfo();             \
         Int_t startnumber = Stack(0)->GetElementNumber();              \
         Int_t index = 0;                                               \
         while (index<n) {                                              \
            elem = (TStreamerElement*)info->GetElements()->At(startnumber++); \
            if (index>0) { PopStack(); WorkWithElement(elem, elem->GetType()); } \
            if (elem->GetType()<TStreamerInfo::kOffsetL) {              \
               SqlWriteBasic(vname[index]);                             \
               index++;                                                 \
            } else {                                                    \
               Int_t elemlen = elem->GetArrayLength();                  \
               SQLWriteArrayContent((vname+index), elemlen, kFALSE);    \
               index+=elemlen;                                          \
            }                                                           \
            fExpectedChain = kFALSE;                                    \
         }                                                              \
      } else {                                                          \
         SQLWriteArrayContent(vname, n, kFALSE);                        \
      }                                                                 \
   }

//______________________________________________________________________________
void TBufferSQL2::WriteFastArray(const Bool_t    *b, Int_t n)
{
   // Write array of Bool_t to buffer

   TBufferSQL2_WriteFastArray(b);
}

//______________________________________________________________________________
void TBufferSQL2::WriteFastArray(const Char_t    *c, Int_t n)
{
   // Write array of Char_t to buffer
   // it will be reproduced as CharStar node with string as attribute

   Bool_t usedefault = (n==0) || fExpectedChain;

   const Char_t* ccc = c;
   // check if no zeros in the array
   if (!usedefault)
      for (int i=0;i<n;i++)
         if (*ccc++==0) { usedefault = kTRUE; break; }

   if (usedefault) {
      TBufferSQL2_WriteFastArray(c);
   } else {
      Char_t* buf = new Char_t[n+1];
      memcpy(buf, c, n);
      buf[n] = 0;
      SqlWriteValue(buf, sqlio::CharStar);
      delete[] buf;
   }
}

//______________________________________________________________________________
void TBufferSQL2::WriteFastArray(const UChar_t   *c, Int_t n)
{
   // Write array of UChar_t to buffer

   TBufferSQL2_WriteFastArray(c);
}

//______________________________________________________________________________
void TBufferSQL2::WriteFastArray(const Short_t   *h, Int_t n)
{
   // Write array of Short_t to buffer

   TBufferSQL2_WriteFastArray(h);
}

//______________________________________________________________________________
void TBufferSQL2::WriteFastArray(const UShort_t  *h, Int_t n)
{
   // Write array of UShort_t to buffer

   TBufferSQL2_WriteFastArray(h);
}

//______________________________________________________________________________
void TBufferSQL2::WriteFastArray(const Int_t     *i, Int_t n)
{
   // Write array of Int_t to buffer

   TBufferSQL2_WriteFastArray(i);
}

//______________________________________________________________________________
void TBufferSQL2::WriteFastArray(const UInt_t    *i, Int_t n)
{
   // Write array of UInt_t to buffer

   TBufferSQL2_WriteFastArray(i);
}

//______________________________________________________________________________
void TBufferSQL2::WriteFastArray(const Long_t    *l, Int_t n)
{
   // Write array of Long_t to buffer

   TBufferSQL2_WriteFastArray(l);
}

//______________________________________________________________________________
void TBufferSQL2::WriteFastArray(const ULong_t   *l, Int_t n)
{
   // Write array of ULong_t to buffer

   TBufferSQL2_WriteFastArray(l);
}

//______________________________________________________________________________
void TBufferSQL2::WriteFastArray(const Long64_t  *l, Int_t n)
{
   // Write array of Long64_t to buffer

   TBufferSQL2_WriteFastArray(l);
}

//______________________________________________________________________________
void TBufferSQL2::WriteFastArray(const ULong64_t *l, Int_t n)
{
   // Write array of ULong64_t to buffer

   TBufferSQL2_WriteFastArray(l);
}

//______________________________________________________________________________
void TBufferSQL2::WriteFastArray(const Float_t   *f, Int_t n)
{
   // Write array of Float_t to buffer

   TBufferSQL2_WriteFastArray(f);
}

//______________________________________________________________________________
void TBufferSQL2::WriteFastArray(const Double_t  *d, Int_t n)
{
   // Write array of Double_t to buffer

   TBufferSQL2_WriteFastArray(d);
}

//______________________________________________________________________________
void TBufferSQL2::WriteFastArrayFloat16(const Float_t  *f, Int_t n, TStreamerElement * /*ele*/)
{
   // Write array of Float16_t to buffer

   TBufferSQL2_WriteFastArray(f);
}

//______________________________________________________________________________
void TBufferSQL2::WriteFastArrayDouble32(const Double_t  *d, Int_t n, TStreamerElement * /*ele*/)
{
   // Write array of Double32_t to buffer

   TBufferSQL2_WriteFastArray(d);
}

//______________________________________________________________________________
void  TBufferSQL2::WriteFastArray(void  *start,  const TClass *cl, Int_t n, TMemberStreamer *streamer)
{
   // Same functionality as TBuffer::WriteFastArray(...) but
   // instead of calling cl->Streamer(obj,buf) call here
   // buf.StreamObject(obj, cl). In that case it is easy to understand where
   // object data is started and finished

   if (streamer) {
      StreamObject(start, streamer, cl, 0);
//      (*streamer)(*this, start, 0);
      return;
   }

   char *obj = (char*)start;
   if (!n) n=1;
   int size = cl->Size();

   for(Int_t j=0; j<n; j++,obj+=size)
      StreamObject(obj, cl);

   //   TBuffer::WriteFastArray(start, cl, n, s);
}

//______________________________________________________________________________
Int_t TBufferSQL2::WriteFastArray(void **start, const TClass *cl, Int_t n, Bool_t isPreAlloc, TMemberStreamer *streamer)
{
   // Same functionality as TBuffer::WriteFastArray(...) but
   // instead of calling cl->Streamer(obj,buf) call here
   // buf.StreamObject(obj, cl). In that case it is easy to understand where
   // object data is started and finished

   if (streamer) {
      StreamObject((void*) start, streamer, cl, 0);
//      (*streamer)(*this,(void*)start,0);
      return 0;
   }

   int strInfo = 0;

   Int_t res = 0;

   if (!isPreAlloc) {

      for (Int_t j=0;j<n;j++) {
         //must write StreamerInfo if pointer is null
         if (!strInfo && !start[j] ) ForceWriteInfo(((TClass*)cl)->GetStreamerInfo(),kFALSE);
         strInfo = 2003;
         res |= WriteObjectAny(start[j],cl);
      }

   } else {
      //case //-> in comment

      for (Int_t j=0;j<n;j++) {
         if (!start[j]) start[j] = ((TClass*)cl)->New();
         StreamObject(start[j], cl);
      }

   }
   return res;

//   return TBuffer::WriteFastArray(startp, cl, n, isPreAlloc, s);
}

//______________________________________________________________________________
void TBufferSQL2::StreamObject(void *obj, const type_info &typeinfo, const TClass *onFileClass)
{
   // steram object to/from buffer

   StreamObject(obj, TClass::GetClass(typeinfo), onFileClass);
}

//______________________________________________________________________________
void TBufferSQL2::StreamObject(void *obj, const char *className, const TClass *onFileClass)
{
   // steram object to/from buffer

   StreamObject(obj, TClass::GetClass(className), onFileClass);
}

//______________________________________________________________________________
void TBufferSQL2::StreamObject(void *obj, const TClass *cl, const TClass *onFileClass)
{
   // steram object to/from buffer

   if (gDebug>1)
      std::cout << " TBufferSQL2::StreamObject class = " << (cl ? cl->GetName() : "none") << std::endl;
   if (IsReading())
      SqlReadObject(obj, 0, 0, 0, onFileClass);
   else
      SqlWriteObject(obj, cl);
}

//______________________________________________________________________________
void TBufferSQL2::StreamObject(TObject *obj)
{
   // steram object to/from buffer

   StreamObject(obj, obj ? obj->IsA() : TObject::Class());
}

//______________________________________________________________________________
void TBufferSQL2::StreamObject(void *obj, TMemberStreamer *streamer, const TClass *cl, Int_t n, const TClass *onFileClass)
{
   // steram object to/from buffer

   if (streamer==0) return;

   if (gDebug>1)
      std::cout << "Stream object of class = " << cl->GetName() << std::endl;
//   (*streamer)(*this, obj, n);

   if (IsReading())
      SqlReadObject(obj, 0, streamer, n, onFileClass);
   else
      SqlWriteObject(obj, cl, streamer, n);
}

// macro for right shift operator for basic type
#define TBufferSQL2_operatorin(vname)           \
   {                                            \
      SqlReadBasic(vname);                      \
   }

//______________________________________________________________________________
void TBufferSQL2::ReadBool(Bool_t    &b)
{
   // Reads Bool_t value from buffer

   TBufferSQL2_operatorin(b);
}

//______________________________________________________________________________
void TBufferSQL2::ReadChar(Char_t    &c)
{
   // Reads Char_t value from buffer

   TBufferSQL2_operatorin(c);
}

//______________________________________________________________________________
void TBufferSQL2::ReadUChar(UChar_t   &c)
{
   // Reads UChar_t value from buffer

   TBufferSQL2_operatorin(c);
}

//______________________________________________________________________________
void TBufferSQL2::ReadShort(Short_t   &h)
{
   // Reads Short_t value from buffer

   TBufferSQL2_operatorin(h);
}

//______________________________________________________________________________
void TBufferSQL2::ReadUShort(UShort_t  &h)
{
   // Reads UShort_t value from buffer

   TBufferSQL2_operatorin(h);
}

//______________________________________________________________________________
void TBufferSQL2::ReadInt(Int_t     &i)
{
   // Reads Int_t value from buffer

   TBufferSQL2_operatorin(i);
}

//______________________________________________________________________________
void TBufferSQL2::ReadUInt(UInt_t    &i)
{
   // Reads UInt_t value from buffer

   TBufferSQL2_operatorin(i);
}

//______________________________________________________________________________
void TBufferSQL2::ReadLong(Long_t    &l)
{
   // Reads Long_t value from buffer

   TBufferSQL2_operatorin(l);
}

//______________________________________________________________________________
void TBufferSQL2::ReadULong(ULong_t   &l)
{
   // Reads ULong_t value from buffer

   TBufferSQL2_operatorin(l);
}

//______________________________________________________________________________
void TBufferSQL2::ReadLong64(Long64_t  &l)
{
   // Reads Long64_t value from buffer

   TBufferSQL2_operatorin(l);
}

//______________________________________________________________________________
void TBufferSQL2::ReadULong64(ULong64_t &l)
{
   // Reads ULong64_t value from buffer

   TBufferSQL2_operatorin(l);
}

//______________________________________________________________________________
void TBufferSQL2::ReadFloat(Float_t   &f)
{
   // Reads Float_t value from buffer

   TBufferSQL2_operatorin(f);
}

//______________________________________________________________________________
void TBufferSQL2::ReadDouble(Double_t  &d)
{
   // Reads Double_t value from buffer

   TBufferSQL2_operatorin(d);
}

//______________________________________________________________________________
void TBufferSQL2::ReadCharP(Char_t    *c)
{
   // Reads array of characters from buffer

   const char* buf = SqlReadCharStarValue();
   if (buf) strcpy(c, buf);
}

//________________________________________________________________________
void TBufferSQL2::ReadTString(TString   &s)
{
   // Read a TString
  
   TBufferFile::ReadTString(s);
}

//________________________________________________________________________
void TBufferSQL2::WriteTString(const TString  &s)
{
   // Write a TString

   TBufferFile::WriteTString(s);
}

//________________________________________________________________________
void TBufferSQL2::ReadStdString(std::string &s)
{
   // Read a std::string
  
   TBufferFile::ReadStdString(s);
}

//________________________________________________________________________
void TBufferSQL2::WriteStdString(const std::string &s)
{
   // Write a std::string

   TBufferFile::WriteStdString(s);
}

// macro for right shift operator for basic types
#define TBufferSQL2_operatorout(vname)          \
   {                                            \
      SqlWriteBasic(vname);                     \
   }

//______________________________________________________________________________
void TBufferSQL2::WriteBool(Bool_t    b)
{
   // Writes Bool_t value to buffer

   TBufferSQL2_operatorout(b);
}

//______________________________________________________________________________
void TBufferSQL2::WriteChar(Char_t    c)
{
   // Writes Char_t value to buffer

   TBufferSQL2_operatorout(c);
}

//______________________________________________________________________________
void TBufferSQL2::WriteUChar(UChar_t   c)
{
   // Writes UChar_t value to buffer

   TBufferSQL2_operatorout(c);
}

//______________________________________________________________________________
void TBufferSQL2::WriteShort(Short_t   h)
{
   // Writes Short_t value to buffer

   TBufferSQL2_operatorout(h);
}

//______________________________________________________________________________
void TBufferSQL2::WriteUShort(UShort_t  h)
{
   // Writes UShort_t value to buffer

   TBufferSQL2_operatorout(h);
}

//______________________________________________________________________________
void TBufferSQL2::WriteInt(Int_t     i)
{
   // Writes Int_t value to buffer

   TBufferSQL2_operatorout(i);
}

//______________________________________________________________________________
void TBufferSQL2::WriteUInt(UInt_t    i)
{
   // Writes UInt_t value to buffer

   TBufferSQL2_operatorout(i);
}

//______________________________________________________________________________
void TBufferSQL2::WriteLong(Long_t    l)
{
   // Writes Long_t value to buffer

   TBufferSQL2_operatorout(l);
}

//______________________________________________________________________________
void TBufferSQL2::WriteULong(ULong_t   l)
{
   // Writes ULong_t value to buffer

   TBufferSQL2_operatorout(l);
}

//______________________________________________________________________________
void TBufferSQL2::WriteLong64(Long64_t  l)
{
   // Writes Long64_t value to buffer

   TBufferSQL2_operatorout(l);
}

//______________________________________________________________________________
void TBufferSQL2::WriteULong64(ULong64_t l)
{
   // Writes ULong64_t value to buffer

   TBufferSQL2_operatorout(l);
}

//______________________________________________________________________________
void TBufferSQL2::WriteFloat(Float_t   f)
{
   // Writes Float_t value to buffer

   TBufferSQL2_operatorout(f);
}

//______________________________________________________________________________
void TBufferSQL2::WriteDouble(Double_t  d)
{
   // Writes Double_t value to buffer

   TBufferSQL2_operatorout(d);
}

//______________________________________________________________________________
void TBufferSQL2::WriteCharP(const Char_t *c)
{
   // Writes array of characters to buffer

   SqlWriteValue(c, sqlio::CharStar);
}

//______________________________________________________________________________
Bool_t TBufferSQL2::SqlWriteBasic(Char_t value)
{
   // converts Char_t to string and creates correspondent sql structure

   char buf[50];
   snprintf(buf, sizeof(buf), "%d", value);
   return SqlWriteValue(buf, sqlio::Char);
}

//______________________________________________________________________________
Bool_t  TBufferSQL2::SqlWriteBasic(Short_t value)
{
   // converts Short_t to string and creates correspondent sql structure

   char buf[50];
   snprintf(buf, sizeof(buf), "%hd", value);
   return SqlWriteValue(buf, sqlio::Short);
}

//______________________________________________________________________________
Bool_t TBufferSQL2::SqlWriteBasic(Int_t value)
{
   // converts Int_t to string and creates correspondent sql structure

   char buf[50];
   snprintf(buf, sizeof(buf), "%d", value);
   return SqlWriteValue(buf, sqlio::Int);
}

//______________________________________________________________________________
Bool_t TBufferSQL2::SqlWriteBasic(Long_t value)
{
   // converts Long_t to string and creates correspondent sql structure

   char buf[50];
   snprintf(buf, sizeof(buf), "%ld", value);
   return SqlWriteValue(buf, sqlio::Long);
}

//______________________________________________________________________________
Bool_t TBufferSQL2::SqlWriteBasic(Long64_t value)
{
   // converts Long64_t to string and creates correspondent sql structure

   char buf[50];
   snprintf(buf, sizeof(buf), "%lld", value);
   return SqlWriteValue(buf, sqlio::Long64);
}

//______________________________________________________________________________
Bool_t  TBufferSQL2::SqlWriteBasic(Float_t value)
{
   // converts Float_t to string and creates correspondent sql structure

   char buf[200];
   snprintf(buf, sizeof(buf), TSQLServer::GetFloatFormat(), value);
   return SqlWriteValue(buf, sqlio::Float);
}

//______________________________________________________________________________
Bool_t TBufferSQL2::SqlWriteBasic(Double_t value)
{
   // converts Double_t to string and creates correspondent sql structure

   char buf[128];
   snprintf(buf, sizeof(buf), TSQLServer::GetFloatFormat(), value);
   return SqlWriteValue(buf, sqlio::Double);
}

//______________________________________________________________________________
Bool_t TBufferSQL2::SqlWriteBasic(Bool_t value)
{
   // converts Bool_t to string and creates correspondent sql structure

   return SqlWriteValue(value ? sqlio::True : sqlio::False, sqlio::Bool);
}

//______________________________________________________________________________
Bool_t TBufferSQL2::SqlWriteBasic(UChar_t value)
{
   // converts UChar_t to string and creates correspondent sql structure

   char buf[50];
   snprintf(buf, sizeof(buf), "%u", value);
   return SqlWriteValue(buf, sqlio::UChar);
}

//______________________________________________________________________________
Bool_t TBufferSQL2::SqlWriteBasic(UShort_t value)
{
   // converts UShort_t to string and creates correspondent sql structure

   char buf[50];
   snprintf(buf, sizeof(buf), "%hu", value);
   return SqlWriteValue(buf, sqlio::UShort);
}

//______________________________________________________________________________
Bool_t TBufferSQL2::SqlWriteBasic(UInt_t value)
{
   // converts UInt_t to string and creates correspondent sql structure

   char buf[50];
   snprintf(buf, sizeof(buf), "%u", value);
   return SqlWriteValue(buf, sqlio::UInt);
}

//______________________________________________________________________________
Bool_t TBufferSQL2::SqlWriteBasic(ULong_t value)
{
   // converts ULong_t to string and creates correspondent sql structure

   char buf[50];
   snprintf(buf, sizeof(buf), "%lu", value);
   return SqlWriteValue(buf, sqlio::ULong);
}

//______________________________________________________________________________
Bool_t TBufferSQL2::SqlWriteBasic(ULong64_t value)
{
   // converts ULong64_t to string and creates correspondent sql structure

   char buf[50];
   snprintf(buf, sizeof(buf), FULong64, value);
   return SqlWriteValue(buf, sqlio::ULong64);
}

//______________________________________________________________________________

Bool_t TBufferSQL2::SqlWriteValue(const char* value, const char* tname)
{
   // create structure in stack, which holds specified value

   Stack()->AddValue(value, tname);

   return kTRUE;
}

//______________________________________________________________________________
void TBufferSQL2::SqlReadBasic(Char_t& value)
{
   // read current value from table and convert it to Char_t value

   const char* res = SqlReadValue(sqlio::Char);
   if (res) {
      int n;
      sscanf(res,"%d", &n);
      value = n;
   } else
      value = 0;
}

//______________________________________________________________________________
void TBufferSQL2::SqlReadBasic(Short_t& value)
{
   // read current value from table and convert it to Short_t value

   const char* res = SqlReadValue(sqlio::Short);
   if (res)
      sscanf(res,"%hd", &value);
   else
      value = 0;
}

//______________________________________________________________________________
void TBufferSQL2::SqlReadBasic(Int_t& value)
{
   // read current value from table and convert it to Int_t value

   const char* res = SqlReadValue(sqlio::Int);
   if (res)
      sscanf(res,"%d", &value);
   else
      value = 0;
}

//______________________________________________________________________________
void TBufferSQL2::SqlReadBasic(Long_t& value)
{
   // read current value from table and convert it to Long_t value

   const char* res = SqlReadValue(sqlio::Long);
   if (res)
      sscanf(res,"%ld", &value);
   else
      value = 0;
}

//______________________________________________________________________________
void TBufferSQL2::SqlReadBasic(Long64_t& value)
{
   // read current value from table and convert it to Long64_t value

   const char* res = SqlReadValue(sqlio::Long64);
   if (res)
      sscanf(res, FLong64, &value);
   else
      value = 0;
}

//______________________________________________________________________________
void TBufferSQL2::SqlReadBasic(Float_t& value)
{
   // read current value from table and convert it to Float_t value

   const char* res = SqlReadValue(sqlio::Float);
   if (res)
      sscanf(res, "%f", &value);
   else
      value = 0.;
}

//______________________________________________________________________________
void TBufferSQL2::SqlReadBasic(Double_t& value)
{
   // read current value from table and convert it to Double_t value

   const char* res = SqlReadValue(sqlio::Double);
   if (res)
      sscanf(res, "%lf", &value);
   else
      value = 0.;
}

//______________________________________________________________________________
void TBufferSQL2::SqlReadBasic(Bool_t& value)
{
   // read current value from table and convert it to Bool_t value

   const char* res = SqlReadValue(sqlio::Bool);
   if (res)
      value = (strcmp(res, sqlio::True)==0);
   else
      value = kFALSE;
}

//______________________________________________________________________________
void TBufferSQL2::SqlReadBasic(UChar_t& value)
{
   // read current value from table and convert it to UChar_t value

   const char* res = SqlReadValue(sqlio::UChar);
   if (res) {
      unsigned int n;
      sscanf(res,"%ud", &n);
      value = n;
   } else
      value = 0;
}

//______________________________________________________________________________
void TBufferSQL2::SqlReadBasic(UShort_t& value)
{
   // read current value from table and convert it to UShort_t value

   const char* res = SqlReadValue(sqlio::UShort);
   if (res)
      sscanf(res,"%hud", &value);
   else
      value = 0;
}

//______________________________________________________________________________
void TBufferSQL2::SqlReadBasic(UInt_t& value)
{
   // read current value from table and convert it to UInt_t value

   const char* res = SqlReadValue(sqlio::UInt);
   if (res)
      sscanf(res,"%u", &value);
   else
      value = 0;
}

//______________________________________________________________________________
void TBufferSQL2::SqlReadBasic(ULong_t& value)
{
   // read current value from table and convert it to ULong_t value

   const char* res = SqlReadValue(sqlio::ULong);
   if (res)
      sscanf(res,"%lu", &value);
   else
      value = 0;
}

//______________________________________________________________________________
void TBufferSQL2::SqlReadBasic(ULong64_t& value)
{
   // read current value from table and convert it to ULong64_t value

   const char* res = SqlReadValue(sqlio::ULong64);
   if (res)
      sscanf(res, FULong64, &value);
   else
      value = 0;
}

//______________________________________________________________________________
const char* TBufferSQL2::SqlReadValue(const char* tname)
{
   // read string value from current stack node

   if (fErrorFlag>0) return 0;

   if (fCurrentData==0) {
      Error("SqlReadValue","No object data to read from");
      fErrorFlag = 1;
      return 0;
   }

   if (!fIgnoreVerification)
      if (!fCurrentData->VerifyDataType(tname)) {
         fErrorFlag = 1;
         return 0;
      }

   fReadBuffer = fCurrentData->GetValue();

   fCurrentData->ShiftToNextValue();

   if (gDebug>4)
      std::cout << "   SqlReadValue " << tname << " = " << fReadBuffer << std::endl;

   return fReadBuffer.Data();
}

//______________________________________________________________________________
const char* TBufferSQL2::SqlReadCharStarValue()
{
   // read CharStar value, if it has special code, request it from large table
   const char* res = SqlReadValue(sqlio::CharStar);
   if ((res==0) || (fSQL==0)) return 0;

   Long64_t objid = Stack()->DefineObjectId(kTRUE);

   Int_t strid = fSQL->IsLongStringCode(objid, res);
   if (strid<=0) return res;

   fSQL->GetLongString(objid, strid, fReadBuffer);

   return fReadBuffer.Data();
}


//______________________________________________________________________________
TSQLStructure* TBufferSQL2::PushStack()
{
   // Push stack with structurual information about streamed object

   TSQLStructure* res = new TSQLStructure;
   if (fStk==0) {
      fStructure = res;
   } else {
      fStk->Add(res);
   }

   fStk = res;   // add in the stack
   return fStk;
}

//______________________________________________________________________________
TSQLStructure* TBufferSQL2::PopStack()
{
   // Pop stack

   if (fStk==0) return 0;
   fStk = fStk->GetParent();
   return fStk;
}

//______________________________________________________________________________
TSQLStructure* TBufferSQL2::Stack(Int_t depth)
{
   // returns head of stack

   TSQLStructure* curr = fStk;
   while ((depth-->0) && (curr!=0)) curr = curr->GetParent();
   return curr;
}


//______________________________________________________________________________
void TBufferSQL2::SetFloatFormat(const char* fmt)
{
   // set printf format for float/double members, default "%e"
   // changes global TSQLServer variable

   TSQLServer::SetFloatFormat(fmt);
}

//______________________________________________________________________________
const char* TBufferSQL2::GetFloatFormat()
{
   // return current printf format for float/double members, default "%e"
   // return format, hold by TSQLServer

   return TSQLServer::GetFloatFormat();
}

//______________________________________________________________________________
Int_t TBufferSQL2::ApplySequence(const TStreamerInfoActions::TActionSequence &sequence, void *obj)
{
   // Read one collection of objects from the buffer using the StreamerInfoLoopAction.
   // The collection needs to be a split TClonesArray or a split vector of pointers.

   TVirtualStreamerInfo *info = sequence.fStreamerInfo;
   IncrementLevel(info);

   if (gDebug) {
      //loop on all active members
      TStreamerInfoActions::ActionContainer_t::const_iterator end = sequence.fActions.end();
      for(TStreamerInfoActions::ActionContainer_t::const_iterator iter = sequence.fActions.begin();
          iter != end;
          ++iter) {
         // Idea: Try to remove this function call as it is really needed only for XML streaming.
         SetStreamerElementNumber((*iter).fConfiguration->fCompInfo->fElem,(*iter).fConfiguration->fCompInfo->fType);
         (*iter).PrintDebug(*this,obj);
         (*iter)(*this,obj);
      }

   } else {
      //loop on all active members
      TStreamerInfoActions::ActionContainer_t::const_iterator end = sequence.fActions.end();
      for(TStreamerInfoActions::ActionContainer_t::const_iterator iter = sequence.fActions.begin();
          iter != end;
          ++iter) {
         // Idea: Try to remove this function call as it is really needed only for XML streaming.
         SetStreamerElementNumber((*iter).fConfiguration->fCompInfo->fElem,(*iter).fConfiguration->fCompInfo->fType);
         (*iter)(*this,obj);
      }
   }

   DecrementLevel(info);
   return 0;
}

//______________________________________________________________________________
Int_t TBufferSQL2::ApplySequenceVecPtr(const TStreamerInfoActions::TActionSequence &sequence, void *start_collection, void *end_collection)
{
   // Read one collection of objects from the buffer using the StreamerInfoLoopAction.
   // The collection needs to be a split TClonesArray or a split vector of pointers.

   TVirtualStreamerInfo *info = sequence.fStreamerInfo;
   IncrementLevel(info);

   if (gDebug) {
      //loop on all active members
      TStreamerInfoActions::ActionContainer_t::const_iterator end = sequence.fActions.end();
      for(TStreamerInfoActions::ActionContainer_t::const_iterator iter = sequence.fActions.begin();
          iter != end;
          ++iter) {
         // Idea: Try to remove this function call as it is really needed only for XML streaming.
         SetStreamerElementNumber((*iter).fConfiguration->fCompInfo->fElem,(*iter).fConfiguration->fCompInfo->fType);
         (*iter).PrintDebug(*this,*(char**)start_collection);  // Warning: This limits us to TClonesArray and vector of pointers.
         (*iter)(*this,start_collection,end_collection);
      }

   } else {
      //loop on all active members
      TStreamerInfoActions::ActionContainer_t::const_iterator end = sequence.fActions.end();
      for(TStreamerInfoActions::ActionContainer_t::const_iterator iter = sequence.fActions.begin();
          iter != end;
          ++iter) {
         // Idea: Try to remove this function call as it is really needed only for XML streaming.
         SetStreamerElementNumber((*iter).fConfiguration->fCompInfo->fElem,(*iter).fConfiguration->fCompInfo->fType);
         (*iter)(*this,start_collection,end_collection);
      }
   }

   DecrementLevel(info);
   return 0;
}

//______________________________________________________________________________
Int_t TBufferSQL2::ApplySequence(const TStreamerInfoActions::TActionSequence &sequence, void *start_collection, void *end_collection)
{
   // Read one collection of objects from the buffer using the StreamerInfoLoopAction.

   TVirtualStreamerInfo *info = sequence.fStreamerInfo;
   IncrementLevel(info);

   TStreamerInfoActions::TLoopConfiguration *loopconfig = sequence.fLoopConfig;
   if (gDebug) {

      // Get the address of the first item for the PrintDebug.
      // (Performance is not essential here since we are going to print to
      // the screen anyway).
      void *arr0 = loopconfig->GetFirstAddress(start_collection,end_collection);
      // loop on all active members
      TStreamerInfoActions::ActionContainer_t::const_iterator end = sequence.fActions.end();
      for(TStreamerInfoActions::ActionContainer_t::const_iterator iter = sequence.fActions.begin();
          iter != end;
          ++iter) {
         // Idea: Try to remove this function call as it is really needed only for XML streaming.
         SetStreamerElementNumber((*iter).fConfiguration->fCompInfo->fElem,(*iter).fConfiguration->fCompInfo->fType);
         (*iter).PrintDebug(*this,arr0);
         (*iter)(*this,start_collection,end_collection,loopconfig);
      }

   } else {
      //loop on all active members
      TStreamerInfoActions::ActionContainer_t::const_iterator end = sequence.fActions.end();
      for(TStreamerInfoActions::ActionContainer_t::const_iterator iter = sequence.fActions.begin();
          iter != end;
          ++iter) {
         // Idea: Try to remove this function call as it is really needed only for XML streaming.
         SetStreamerElementNumber((*iter).fConfiguration->fCompInfo->fElem,(*iter).fConfiguration->fCompInfo->fType);
         (*iter)(*this,start_collection,end_collection,loopconfig);
      }
   }

   DecrementLevel(info);
   return 0;
}

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