ROOT logo
/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/


//-------------------------------------------------------
//          Implementation of the TPC tracker
//
//   Origin: Marian Ivanov   Marian.Ivanov@cern.ch
// 
//  AliTPC parallel tracker
//
//  The track fitting is based on Kalman filtering approach
//  The track finding steps:
//      1. Seeding - with and without vertex constraint
//                 - seeding with vertex constain done at first n^2 proble
//                 - seeding without vertex constraint n^3 problem
//      2. Tracking - follow prolongation road - find cluster - update kalman track
//  The seeding and tracking is repeated several times, in different seeding region.
//  This approach enables to find the track which cannot be seeded in some region of TPC
//  This can happen because of low momenta (track do not reach outer radius), or track is currently in the ded region between sectors, or the track is for the moment overlapped with other track (seed quality is poor) ...

//  With this approach we reach almost 100 % efficiency also for high occupancy events.
//  (If the seeding efficiency in a region is about 90 % than with logical or of several 
//  regions we will reach 100% (in theory - supposing independence) 

//  Repeating several seeding - tracking procedures some of the tracks can be find 
//  several times. 

//  The procedures to remove multi find tacks are impremented:
//  RemoveUsed2 - fast procedure n problem - 
//                 Algorithm - Sorting tracks according quality
//                             remove tracks with some shared fraction 
//                             Sharing in respect to all tacks 
//                             Signing clusters in gold region
//  FindSplitted - slower algorithm n^2
//                 Sort the tracks according quality
//                 Loop over pair of tracks
//                 If overlap with other track bigger than threshold - remove track
//  
//  FindCurling  - Finds the pair of tracks which are curling
//               - About 10% of tracks can be find with this procedure
//                 The combinatorial background is too big to be used in High 
//                  multiplicity environment 
//               - n^2 problem - Slow procedure - currently it is disabled because of 
//                  low efficiency
//                 
//  The number of splitted tracks can be reduced disabling the sharing of the cluster.
//  tpcRecoParam-> SetClusterSharing(kFALSE);
//  IT IS HIGHLY non recomended to use it in high flux enviroonment
//  Even using this switch some tracks can be found more than once 
//  (because of multiple seeding and low quality tracks which will not cross full chamber)
//                          
//
// The tracker itself can be debugged  - the information about tracks can be stored in several // phases of the reconstruction
// To enable storage of the TPC tracks in the ESD friend track
// use AliTPCReconstructor::SetStreamLevel(n); 
//
// The debug level -  different procedure produce tree for numerical debugging of code and data (see comments foEStreamFlags in AliTPCtracker.h  )
//

//
// Adding systematic errors to the covariance:
// 
// The systematic errors due to the misalignment and miscalibration are added to the covariance matrix
// of the tracks (not to the clusters as they are dependent):
// The parameters form AliTPCRecoParam are used AliTPCRecoParam::GetSystematicError
// The systematic errors are expressed there in RMS - position (cm), angle (rad), curvature (1/GeV)
// The default values are 0. 
//
// The systematic errors are added to the covariance matrix in following places:
//
// 1. During fisrt itteration - AliTPCtracker::FillESD
// 2. Second iteration - 
//      2.a ITS->TPC   - AliTPCtracker::ReadSeeds 
//      2.b TPC->TRD   - AliTPCtracker::PropagateBack
// 3. Third iteration  -
//      3.a TRD->TPC   - AliTPCtracker::ReadSeeds
//      3.b TPC->ITS   - AliTPCtracker::RefitInward
//

/* $Id$ */

#include "Riostream.h"
#include <TClonesArray.h>
#include <TFile.h>
#include <TObjArray.h>
#include <TTree.h>
#include <TMatrixD.h>
#include <TGraphErrors.h>
#include <TTimeStamp.h>
#include "AliLog.h"
#include "AliComplexCluster.h"
#include "AliESDEvent.h"
#include "AliESDtrack.h"
#include "AliESDVertex.h"
#include "AliKink.h"
#include "AliV0.h"
#include "AliHelix.h"
#include "AliRunLoader.h"
#include "AliTPCClustersRow.h"
#include "AliTPCParam.h"
#include "AliTPCReconstructor.h"
#include "AliTPCpolyTrack.h"
#include "AliTPCreco.h"
#include "AliTPCseed.h"

#include "AliTPCtrackerSector.h" 
#include "AliTPCtracker.h"
#include "TStopwatch.h"
#include "AliTPCReconstructor.h"
#include "AliAlignObj.h"
#include "AliTrackPointArray.h"
#include "TRandom.h"
#include "AliTPCcalibDB.h"
#include "AliTPCcalibDButil.h"
#include "AliTPCTransform.h"
#include "AliTPCClusterParam.h"
#include "AliTPCdEdxInfo.h"
#include "AliDCSSensorArray.h"
#include "AliDCSSensor.h"
#include "AliDAQ.h"
#include "AliCosmicTracker.h"
#include "AliTPCROC.h"
#include "AliMathBase.h"
//

using std::cerr;
using std::endl;
ClassImp(AliTPCtracker)



class AliTPCFastMath {
public:
  AliTPCFastMath();  
  static Double_t FastAsin(Double_t x);   
 private: 
  static Double_t fgFastAsin[20000];  //lookup table for fast asin computation
};

Double_t AliTPCFastMath::fgFastAsin[20000];
AliTPCFastMath gAliTPCFastMath; // needed to fill the LUT

AliTPCFastMath::AliTPCFastMath(){
  //
  // initialized lookup table;
  for (Int_t i=0;i<10000;i++){
    fgFastAsin[2*i] = TMath::ASin(i/10000.);
    fgFastAsin[2*i+1] = (TMath::ASin((i+1)/10000.)-fgFastAsin[2*i]);
  }
}

Double_t AliTPCFastMath::FastAsin(Double_t x){
  //
  // return asin using lookup table
  if (x>0){
    Int_t index = int(x*10000);
    return fgFastAsin[2*index]+(x*10000.-index)*fgFastAsin[2*index+1];
  }
  x*=-1;
  Int_t index = int(x*10000);
  return -(fgFastAsin[2*index]+(x*10000.-index)*fgFastAsin[2*index+1]);
}
//__________________________________________________________________
AliTPCtracker::AliTPCtracker()
                :AliTracker(),
		 fkNIS(0),
		 fInnerSec(0),
		 fkNOS(0),
		 fOuterSec(0),
		 fN(0),
		 fSectors(0),
		 fInput(0),
		 fOutput(0),
		 fSeedTree(0),
		 fTreeDebug(0),
		 fEvent(0),
		 fEventHLT(0),
		 fDebug(0),
		 fNewIO(kFALSE),
		 fNtracks(0),
		 fSeeds(0),
		 fIteration(0),
		 fkParam(0),
		 fDebugStreamer(0),
		 fUseHLTClusters(4),
         fCrossTalkSignalArray(0),
		 fSeedsPool(0),
		 fFreeSeedsID(500),
		 fNFreeSeeds(0),
		 fLastSeedID(-1)
{
  //
  // default constructor
  //
  for (Int_t irow=0; irow<200; irow++){
    fXRow[irow]=0;
    fYMax[irow]=0;
    fPadLength[irow]=0;
  }
}
//_____________________________________________________________________



Int_t AliTPCtracker::UpdateTrack(AliTPCseed * track, Int_t accept){
  //
  //update track information using current cluster - track->fCurrentCluster


  AliTPCclusterMI* c =track->GetCurrentCluster();
  if (accept > 0) //sign not accepted clusters
    track->SetCurrentClusterIndex1(track->GetCurrentClusterIndex1() | 0x8000);  
  else // unsign accpeted clusters
    track->SetCurrentClusterIndex1(track->GetCurrentClusterIndex1() & 0xffff7fff);  
  UInt_t i = track->GetCurrentClusterIndex1();

  Int_t sec=(i&0xff000000)>>24; 
  //Int_t row = (i&0x00ff0000)>>16; 
  track->SetRow((i&0x00ff0000)>>16);
  track->SetSector(sec);
  //  Int_t index = i&0xFFFF;
  if (sec>=fkParam->GetNInnerSector()) track->SetRow(track->GetRow()+fkParam->GetNRowLow()); 
  track->SetClusterIndex2(track->GetRow(), i);  
  //track->fFirstPoint = row;
  //if ( track->fLastPoint<row) track->fLastPoint =row;
  //  if (track->fRow<0 || track->fRow>160) {
  //  printf("problem\n");
  //}
  if (track->GetFirstPoint()>track->GetRow()) 
    track->SetFirstPoint(track->GetRow());
  if (track->GetLastPoint()<track->GetRow()) 
    track->SetLastPoint(track->GetRow());
  

  track->SetClusterPointer(track->GetRow(),c);  
  //

  Double_t angle2 = track->GetSnp()*track->GetSnp();
  //
  //SET NEW Track Point
  //
  if (angle2<1) //PH sometimes angle2 is very big. To be investigated...
  {
    angle2 = TMath::Sqrt(angle2/(1-angle2)); 
    AliTPCTrackerPoint   &point =*(track->GetTrackPoint(track->GetRow()));
    //
    point.SetSigmaY(c->GetSigmaY2()/track->GetCurrentSigmaY2());
    point.SetSigmaZ(c->GetSigmaZ2()/track->GetCurrentSigmaZ2());
    point.SetErrY(sqrt(track->GetErrorY2()));
    point.SetErrZ(sqrt(track->GetErrorZ2()));
    //
    point.SetX(track->GetX());
    point.SetY(track->GetY());
    point.SetZ(track->GetZ());
    point.SetAngleY(angle2);
    point.SetAngleZ(track->GetTgl());
    if (point.IsShared()){
      track->SetErrorY2(track->GetErrorY2()*4);
      track->SetErrorZ2(track->GetErrorZ2()*4);
    }
  }  

  Double_t chi2 = track->GetPredictedChi2(track->GetCurrentCluster());
  //
//   track->SetErrorY2(track->GetErrorY2()*1.3);
//   track->SetErrorY2(track->GetErrorY2()+0.01);    
//   track->SetErrorZ2(track->GetErrorZ2()*1.3);   
//   track->SetErrorZ2(track->GetErrorZ2()+0.005);      
    //}
  if (accept>0) return 0;
  if (track->GetNumberOfClusters()%20==0){
    //    if (track->fHelixIn){
    //  TClonesArray & larr = *(track->fHelixIn);    
    //  Int_t ihelix = larr.GetEntriesFast();
    //  new(larr[ihelix]) AliHelix(*track) ;    
    //}
  }
  if (AliTPCReconstructor::StreamLevel()&kStreamUpdateTrack) {
    Int_t event = (fEvent==NULL)? 0: fEvent->GetEventNumberInFile();
    AliExternalTrackParam param(*track);
    TTreeSRedirector &cstream = *fDebugStreamer;
    cstream<<"UpdateTrack"<<
      "cl.="<<c<<
      "event="<<event<<
      "track.="<<&param<<
      "\n";
  }
  track->SetNoCluster(0);
  return track->Update(c,chi2,i);
}



Int_t AliTPCtracker::AcceptCluster(AliTPCseed * seed, AliTPCclusterMI * cluster)
{
  //
  // decide according desired precision to accept given 
  // cluster for tracking
  Double_t  yt=0,zt=0;
  seed->GetProlongation(cluster->GetX(),yt,zt);
  Double_t sy2=ErrY2(seed,cluster);
  Double_t sz2=ErrZ2(seed,cluster);
  
  Double_t sdistancey2 = sy2+seed->GetSigmaY2();
  Double_t sdistancez2 = sz2+seed->GetSigmaZ2();
  Double_t dy=seed->GetCurrentCluster()->GetY()-yt;
  Double_t dz=seed->GetCurrentCluster()->GetZ()-zt;
  Double_t rdistancey2 = (seed->GetCurrentCluster()->GetY()-yt)*
    (seed->GetCurrentCluster()->GetY()-yt)/sdistancey2;
  Double_t rdistancez2 = (seed->GetCurrentCluster()->GetZ()-zt)*
    (seed->GetCurrentCluster()->GetZ()-zt)/sdistancez2;
  
  Double_t rdistance2  = rdistancey2+rdistancez2;
  //Int_t  accept =0;
  
  if (AliTPCReconstructor::StreamLevel()>2 && ( (fIteration>0)|| (seed->GetNumberOfClusters()>20))) {
    //  if (AliTPCReconstructor::StreamLevel()>2 && seed->GetNumberOfClusters()>20) {
    Float_t rmsy2 = seed->GetCurrentSigmaY2();
    Float_t rmsz2 = seed->GetCurrentSigmaZ2();
    Float_t rmsy2p30 = seed->GetCMeanSigmaY2p30();
    Float_t rmsz2p30 = seed->GetCMeanSigmaZ2p30();
    Float_t rmsy2p30R  = seed->GetCMeanSigmaY2p30R();
    Float_t rmsz2p30R  = seed->GetCMeanSigmaZ2p30R();
    AliExternalTrackParam param(*seed);
    static TVectorD gcl(3),gtr(3);
    Float_t gclf[3];
    param.GetXYZ(gcl.GetMatrixArray());
    cluster->GetGlobalXYZ(gclf);
    gcl[0]=gclf[0];    gcl[1]=gclf[1];    gcl[2]=gclf[2];
    Int_t nclSeed=seed->GetNumberOfClusters();
    
    if (AliTPCReconstructor::StreamLevel()&kStreamErrParam) { // flag:stream in debug mode cluster and track extrapolation at given row together with error nad shape estimate
      Int_t eventNr = fEvent->GetEventNumberInFile();
	
    (*fDebugStreamer)<<"ErrParam"<<
      "iter="<<fIteration<<
      "eventNr="<<eventNr<<
      "Cl.="<<cluster<<
      "nclSeed="<<nclSeed<<
      "T.="<<&param<<
      "dy="<<dy<<
      "dz="<<dz<<
      "yt="<<yt<<
      "zt="<<zt<<
      "gcl.="<<&gcl<<
      "gtr.="<<&gtr<<
      "erry2="<<sy2<<
      "errz2="<<sz2<<
      "rmsy2="<<rmsy2<<
      "rmsz2="<<rmsz2<<	
      "rmsy2p30="<<rmsy2p30<<
      "rmsz2p30="<<rmsz2p30<<	
      "rmsy2p30R="<<rmsy2p30R<<
      "rmsz2p30R="<<rmsz2p30R<<	
      // normalize distance - 
      "rdisty="<<rdistancey2<<
      "rdistz="<<rdistancez2<<
      "rdist="<<rdistance2<< //       
      "\n";
    }
  }
  //return 0;  // temporary
  if (rdistance2>32) return 3;
  
  
  if ((rdistancey2>9. || rdistancez2>9.) && cluster->GetType()==0)  
    return 2;  //suspisiouce - will be changed
  
  if ((rdistancey2>6.25 || rdistancez2>6.25) && cluster->GetType()>0)  
    // strict cut on overlaped cluster
    return  2;  //suspisiouce - will be changed
  
  if ( (rdistancey2>1. || rdistancez2>6.25 ) 
       && cluster->GetType()<0){
    seed->SetNFoundable(seed->GetNFoundable()-1);
    return 2;    
  }

  if (fUseHLTClusters == 3 || fUseHLTClusters == 4) {
    if (fIteration==2){
      if(!AliTPCReconstructor::GetRecoParam()->GetUseHLTOnePadCluster()) {
	if (TMath::Abs(cluster->GetSigmaY2()) < kAlmost0)
	  return 2;
      }
    }
  }

  return 0;
}





//_____________________________________________________________________________
AliTPCtracker::AliTPCtracker(const AliTPCParam *par): 
AliTracker(), 
		 fkNIS(par->GetNInnerSector()/2),
		 fInnerSec(0),
		 fkNOS(par->GetNOuterSector()/2),
		 fOuterSec(0),
		 fN(0),
		 fSectors(0),
		 fInput(0),
		 fOutput(0),
		 fSeedTree(0),
		 fTreeDebug(0),
		 fEvent(0),
		 fEventHLT(0),
		 fDebug(0),
		 fNewIO(0),
		 fNtracks(0),
		 fSeeds(0),
		 fIteration(0),
		 fkParam(0),
         fDebugStreamer(0),
         fUseHLTClusters(4),
         fCrossTalkSignalArray(0),
         fSeedsPool(0),
		 fFreeSeedsID(500),
		 fNFreeSeeds(0),
		 fLastSeedID(-1)
{
  //---------------------------------------------------------------------
  // The main TPC tracker constructor
  //---------------------------------------------------------------------
  fInnerSec=new AliTPCtrackerSector[fkNIS];         
  fOuterSec=new AliTPCtrackerSector[fkNOS];
 
  Int_t i;
  for (i=0; i<fkNIS; i++) fInnerSec[i].Setup(par,0);
  for (i=0; i<fkNOS; i++) fOuterSec[i].Setup(par,1);

  fkParam = par;  
  Int_t nrowlow = par->GetNRowLow();
  Int_t nrowup = par->GetNRowUp();

  
  for (i=0;i<nrowlow;i++){
    fXRow[i]     = par->GetPadRowRadiiLow(i);
    fPadLength[i]= par->GetPadPitchLength(0,i);
    fYMax[i]     = fXRow[i]*TMath::Tan(0.5*par->GetInnerAngle());
  }

  
  for (i=0;i<nrowup;i++){
    fXRow[i+nrowlow]      = par->GetPadRowRadiiUp(i);
    fPadLength[i+nrowlow] = par->GetPadPitchLength(60,i);
    fYMax[i+nrowlow]      = fXRow[i+nrowlow]*TMath::Tan(0.5*par->GetOuterAngle());
  }

  if (AliTPCReconstructor::StreamLevel()>0) {
    fDebugStreamer = new TTreeSRedirector("TPCdebug.root","recreate");
  }
  //
  fSeedsPool = new TClonesArray("AliTPCseed",1000);

  // crosstalk array and matrix initialization
  Int_t nROCs   = 72;
  Int_t nTimeBinsAll  = par->GetMaxTBin();
  Int_t nWireSegments = 11;
  fCrossTalkSignalArray = new TObjArray(nROCs*4);  //  
  fCrossTalkSignalArray->SetOwner(kTRUE);
  for (Int_t isector=0; isector<4*nROCs; isector++){
    TMatrixD * crossTalkSignal = new TMatrixD(nWireSegments,nTimeBinsAll);
    for (Int_t imatrix = 0; imatrix<11; imatrix++)
      for (Int_t jmatrix = 0; jmatrix<nTimeBinsAll; jmatrix++){
        (*crossTalkSignal)[imatrix][jmatrix]=0.;
      }
    fCrossTalkSignalArray->AddAt(crossTalkSignal,isector);
  }

}
//________________________________________________________________________
AliTPCtracker::AliTPCtracker(const AliTPCtracker &t):
  AliTracker(t),
		 fkNIS(t.fkNIS),
		 fInnerSec(0),
		 fkNOS(t.fkNOS),
		 fOuterSec(0),
		 fN(0),
		 fSectors(0),
		 fInput(0),
		 fOutput(0),
		 fSeedTree(0),
		 fTreeDebug(0),
		 fEvent(0),
		 fEventHLT(0),
		 fDebug(0),
		 fNewIO(kFALSE),
		 fNtracks(0),
		 fSeeds(0),
		 fIteration(0),
		 fkParam(0),
         fDebugStreamer(0),
         fUseHLTClusters(4),
         fCrossTalkSignalArray(0),
         fSeedsPool(0),
		 fFreeSeedsID(500),
		 fNFreeSeeds(0),
		 fLastSeedID(-1)
{
  //------------------------------------
  // dummy copy constructor
  //------------------------------------------------------------------
  fOutput=t.fOutput;
  for (Int_t irow=0; irow<200; irow++){
    fXRow[irow]=0;
    fYMax[irow]=0;
    fPadLength[irow]=0;
  }

}
AliTPCtracker & AliTPCtracker::operator=(const AliTPCtracker& /*r*/)
{
  //------------------------------
  // dummy 
  //--------------------------------------------------------------
  return *this;
}
//_____________________________________________________________________________
AliTPCtracker::~AliTPCtracker() {
  //------------------------------------------------------------------
  // TPC tracker destructor
  //------------------------------------------------------------------
  delete[] fInnerSec;
  delete[] fOuterSec;
  if (fSeeds) {
    fSeeds->Clear(); 
    delete fSeeds;
  }
  if (fCrossTalkSignalArray) delete fCrossTalkSignalArray;
  if (fDebugStreamer) delete fDebugStreamer;
  if (fSeedsPool) delete fSeedsPool;
}


void AliTPCtracker::FillESD(const TObjArray* arr)
{
  //
  //
  //fill esds using updated tracks

  if (!fEvent) return;

  AliESDtrack iotrack;
  
    // write tracks to the event
    // store index of the track
    Int_t nseed=arr->GetEntriesFast();
    //FindKinks(arr,fEvent);
    for (Int_t i=0; i<nseed; i++) {
      AliTPCseed *pt=(AliTPCseed*)arr->UncheckedAt(i);    
      if (!pt) continue; 
      pt->UpdatePoints();
      AddCovariance(pt);
      if (AliTPCReconstructor::StreamLevel()&kStreamFillESD) {
	(*fDebugStreamer)<<"FillESD"<<  // flag: stream track information in FillESD function (after track Iteration 0)
	  "Tr0.="<<pt<<
	  "\n";       
      }
      //      pt->PropagateTo(fkParam->GetInnerRadiusLow());
      if (pt->GetKinkIndex(0)<=0){  //don't propagate daughter tracks 
	pt->PropagateTo(fkParam->GetInnerRadiusLow());
      }
 
      if (( pt->GetPoints()[2]- pt->GetPoints()[0])>5 && pt->GetPoints()[3]>0.8){
	iotrack.~AliESDtrack();
	new(&iotrack) AliESDtrack;
	iotrack.UpdateTrackParams(pt,AliESDtrack::kTPCin);
        iotrack.SetTPCsignal(pt->GetdEdx(), pt->GetSDEDX(0), pt->GetNCDEDX(0)); 
	iotrack.SetTPCPoints(pt->GetPoints());
	iotrack.SetKinkIndexes(pt->GetKinkIndexes());
	iotrack.SetV0Indexes(pt->GetV0Indexes());
	//	iotrack.SetTPCpid(pt->fTPCr);
	//iotrack.SetTPCindex(i); 
	MakeESDBitmaps(pt, &iotrack);
	fEvent->AddTrack(&iotrack);
	continue;
      }
       
      if ( (pt->GetNumberOfClusters()>70)&& (Float_t(pt->GetNumberOfClusters())/Float_t(pt->GetNFoundable()))>0.55) {
	iotrack.~AliESDtrack();
	new(&iotrack) AliESDtrack;
	iotrack.UpdateTrackParams(pt,AliESDtrack::kTPCin);
        iotrack.SetTPCsignal(pt->GetdEdx(), pt->GetSDEDX(0), pt->GetNCDEDX(0)); 
	iotrack.SetTPCPoints(pt->GetPoints());
	//iotrack.SetTPCindex(i);
	iotrack.SetKinkIndexes(pt->GetKinkIndexes());
	iotrack.SetV0Indexes(pt->GetV0Indexes());
	MakeESDBitmaps(pt, &iotrack);
	//	iotrack.SetTPCpid(pt->fTPCr);
	fEvent->AddTrack(&iotrack);
	continue;
      } 
      //
      // short tracks  - maybe decays

      if ( (pt->GetNumberOfClusters()>30) && (Float_t(pt->GetNumberOfClusters())/Float_t(pt->GetNFoundable()))>0.70) {
	Int_t found,foundable,shared;
	pt->GetClusterStatistic(0,60,found, foundable,shared,kFALSE);
	if ( (found>20) && (pt->GetNShared()/float(pt->GetNumberOfClusters())<0.2)){
	  iotrack.~AliESDtrack();
	  new(&iotrack) AliESDtrack;
	  iotrack.UpdateTrackParams(pt,AliESDtrack::kTPCin);	
	  iotrack.SetTPCsignal(pt->GetdEdx(), pt->GetSDEDX(0), pt->GetNCDEDX(0)); 
	  //iotrack.SetTPCindex(i);
	  iotrack.SetTPCPoints(pt->GetPoints());
	  iotrack.SetKinkIndexes(pt->GetKinkIndexes());
	  iotrack.SetV0Indexes(pt->GetV0Indexes());
	  MakeESDBitmaps(pt, &iotrack);
	  //iotrack.SetTPCpid(pt->fTPCr);
	  fEvent->AddTrack(&iotrack);
	  continue;
	}
      }       
      
      if ( (pt->GetNumberOfClusters()>20) && (Float_t(pt->GetNumberOfClusters())/Float_t(pt->GetNFoundable()))>0.8) {
	Int_t found,foundable,shared;
	pt->GetClusterStatistic(0,60,found, foundable,shared,kFALSE);
	if (found<20) continue;
	if (pt->GetNShared()/float(pt->GetNumberOfClusters())>0.2) continue;
	//
	iotrack.~AliESDtrack();
	new(&iotrack) AliESDtrack;
	iotrack.UpdateTrackParams(pt,AliESDtrack::kTPCin);	
        iotrack.SetTPCsignal(pt->GetdEdx(), pt->GetSDEDX(0), pt->GetNCDEDX(0)); 
	iotrack.SetTPCPoints(pt->GetPoints());
	iotrack.SetKinkIndexes(pt->GetKinkIndexes());
	iotrack.SetV0Indexes(pt->GetV0Indexes());
	MakeESDBitmaps(pt, &iotrack);
	//iotrack.SetTPCpid(pt->fTPCr);
	//iotrack.SetTPCindex(i);
	fEvent->AddTrack(&iotrack);
	continue;
      }   
      // short tracks  - secondaties
      //
      if ( (pt->GetNumberOfClusters()>30) ) {
	Int_t found,foundable,shared;
	pt->GetClusterStatistic(128,158,found, foundable,shared,kFALSE);
	if ( (found>20) && (pt->GetNShared()/float(pt->GetNumberOfClusters())<0.2) &&float(found)/float(foundable)>0.8){
	  iotrack.~AliESDtrack();
	  new(&iotrack) AliESDtrack;
	  iotrack.UpdateTrackParams(pt,AliESDtrack::kTPCin);	
	  iotrack.SetTPCsignal(pt->GetdEdx(), pt->GetSDEDX(0), pt->GetNCDEDX(0)); 
	  iotrack.SetTPCPoints(pt->GetPoints());
	  iotrack.SetKinkIndexes(pt->GetKinkIndexes());
	  iotrack.SetV0Indexes(pt->GetV0Indexes());
	  MakeESDBitmaps(pt, &iotrack);
	  //iotrack.SetTPCpid(pt->fTPCr);	
	  //iotrack.SetTPCindex(i);
	  fEvent->AddTrack(&iotrack);
	  continue;
	}
      }       
      
      if ( (pt->GetNumberOfClusters()>15)) {
	Int_t found,foundable,shared;
	pt->GetClusterStatistic(138,158,found, foundable,shared,kFALSE);
	if (found<15) continue;
	if (foundable<=0) continue;
	if (pt->GetNShared()/float(pt->GetNumberOfClusters())>0.2) continue;
	if (float(found)/float(foundable)<0.8) continue;
	//
	iotrack.~AliESDtrack();
	new(&iotrack) AliESDtrack;
	iotrack.UpdateTrackParams(pt,AliESDtrack::kTPCin);	
        iotrack.SetTPCsignal(pt->GetdEdx(), pt->GetSDEDX(0), pt->GetNCDEDX(0)); 
	iotrack.SetTPCPoints(pt->GetPoints());
	iotrack.SetKinkIndexes(pt->GetKinkIndexes());
	iotrack.SetV0Indexes(pt->GetV0Indexes());
	MakeESDBitmaps(pt, &iotrack);
	//	iotrack.SetTPCpid(pt->fTPCr);
	//iotrack.SetTPCindex(i);
	fEvent->AddTrack(&iotrack);
	continue;
      }   
    }
    // >> account for suppressed tracks in the kink indices (RS)
    int nESDtracks = fEvent->GetNumberOfTracks();
    for (int it=nESDtracks;it--;) {
      AliESDtrack* esdTr = fEvent->GetTrack(it);
      if (!esdTr || !esdTr->GetKinkIndex(0)) continue;
      for (int ik=0;ik<3;ik++) {
	int knkId=0;
	if (!(knkId=esdTr->GetKinkIndex(ik))) break; // no more kinks for this track
	AliESDkink* kink = fEvent->GetKink(TMath::Abs(knkId)-1);
	if (!kink) {
	  AliError(Form("ESDTrack%d refers to non-existing kink %d",it,TMath::Abs(knkId)-1));
	  continue;
	}
	kink->SetIndex(it, knkId<0 ? 0:1); // update track index of the kink: mother at 0, daughter at 1
      }
    }

    // << account for suppressed tracks in the kink indices (RS)  
    AliInfo(Form("Number of filled ESDs-\t%d\n",fEvent->GetNumberOfTracks()));
  
}





Double_t AliTPCtracker::ErrY2(AliTPCseed* seed, const AliTPCclusterMI * cl){
  //
  //
  // Use calibrated cluster error from OCDB
  //
  AliTPCClusterParam * clparam = AliTPCcalibDB::Instance()->GetClusterParam();
  //
  Float_t z = TMath::Abs(fkParam->GetZLength(0)-TMath::Abs(seed->GetZ()));
  Int_t ctype = cl->GetType();  
  Int_t    type = (cl->GetRow()<63) ? 0: (cl->GetRow()>126) ? 1:2;
  Double_t angle = seed->GetSnp()*seed->GetSnp();
  angle = TMath::Sqrt(TMath::Abs(angle/(1.-angle)));
  Double_t erry2 = clparam->GetError0Par(0,type, z,angle);
  if (ctype<0) {
    erry2+=0.5;  // edge cluster
  }
  erry2*=erry2;
  Double_t addErr=0;
  const Double_t *errInner = AliTPCReconstructor::GetRecoParam()->GetSystematicErrorClusterInner();
  addErr=errInner[0]*TMath::Exp(-TMath::Abs((cl->GetX()-85.)/errInner[1]));
  erry2+=addErr*addErr;
  const Double_t *errCluster = AliTPCReconstructor::GetRecoParam()->GetSystematicErrorCluster();
  erry2+=errCluster[0]*errCluster[0];
  seed->SetErrorY2(erry2);
  //
  return erry2;

//calculate look-up table at the beginning
//   static Bool_t  ginit = kFALSE;
//   static Float_t gnoise1,gnoise2,gnoise3;
//   static Float_t ggg1[10000];
//   static Float_t ggg2[10000];
//   static Float_t ggg3[10000];
//   static Float_t glandau1[10000];
//   static Float_t glandau2[10000];
//   static Float_t glandau3[10000];
//   //
//   static Float_t gcor01[500];
//   static Float_t gcor02[500];
//   static Float_t gcorp[500];
//   //

//   //
//   if (ginit==kFALSE){
//     for (Int_t i=1;i<500;i++){
//       Float_t rsigma = float(i)/100.;
//       gcor02[i] = TMath::Max(0.78 +TMath::Exp(7.4*(rsigma-1.2)),0.6);
//       gcor01[i] = TMath::Max(0.72 +TMath::Exp(3.36*(rsigma-1.2)),0.6);
//       gcorp[i]  = TMath::Max(TMath::Power((rsigma+0.5),1.5),1.2);
//     }

//     //
//     for (Int_t i=3;i<10000;i++){
//       //
//       //
//       // inner sector
//       Float_t amp = float(i);
//       Float_t padlength =0.75;
//       gnoise1 = 0.0004/padlength;
//       Float_t nel     = 0.268*amp;
//       Float_t nprim   = 0.155*amp;
//       ggg1[i]          = fkParam->GetDiffT()*fkParam->GetDiffT()*(2+0.001*nel/(padlength*padlength))/nel;
//       glandau1[i]      = (2.+0.12*nprim)*0.5* (2.+nprim*nprim*0.001/(padlength*padlength))/nprim;
//       if (glandau1[i]>1) glandau1[i]=1;
//       glandau1[i]*=padlength*padlength/12.;      
//       //
//       // outer short
//       padlength =1.;
//       gnoise2   = 0.0004/padlength;
//       nel       = 0.3*amp;
//       nprim     = 0.133*amp;
//       ggg2[i]      = fkParam->GetDiffT()*fkParam->GetDiffT()*(2+0.0008*nel/(padlength*padlength))/nel;
//       glandau2[i]  = (2.+0.12*nprim)*0.5*(2.+nprim*nprim*0.001/(padlength*padlength))/nprim;
//       if (glandau2[i]>1) glandau2[i]=1;
//       glandau2[i]*=padlength*padlength/12.;
//       //
//       //
//       // outer long
//       padlength =1.5;
//       gnoise3   = 0.0004/padlength;
//       nel       = 0.3*amp;
//       nprim     = 0.133*amp;
//       ggg3[i]      = fkParam->GetDiffT()*fkParam->GetDiffT()*(2+0.0008*nel/(padlength*padlength))/nel;
//       glandau3[i]  = (2.+0.12*nprim)*0.5*(2.+nprim*nprim*0.001/(padlength*padlength))/nprim;
//       if (glandau3[i]>1) glandau3[i]=1;
//       glandau3[i]*=padlength*padlength/12.;
//       //
//     }
//     ginit = kTRUE;
//   }
//   //
//   //
//   //
//   Int_t amp = int(TMath::Abs(cl->GetQ()));  
//   if (amp>9999) {
//     seed->SetErrorY2(1.);
//     return 1.;
//   }
//   Float_t snoise2;
//   Float_t z = TMath::Abs(fkParam->GetZLength(0)-TMath::Abs(seed->GetZ()));
//   Int_t ctype = cl->GetType();  
//   Float_t padlength= GetPadPitchLength(seed->GetRow());
//   Double_t angle2 = seed->GetSnp()*seed->GetSnp();
//   angle2 = angle2/(1-angle2); 
//   //
//   //cluster "quality"
//   Int_t rsigmay = int(100.*cl->GetSigmaY2()/(seed->GetCurrentSigmaY2()));
//   Float_t res;
//   //
//   if (fSectors==fInnerSec){
//     snoise2 = gnoise1;
//     res     = ggg1[amp]*z+glandau1[amp]*angle2;     
//     if (ctype==0) res *= gcor01[rsigmay];
//     if ((ctype>0)){
//       res+=0.002;
//       res*= gcorp[rsigmay];
//     }
//   }
//   else {
//     if (padlength<1.1){
//       snoise2 = gnoise2;
//       res     = ggg2[amp]*z+glandau2[amp]*angle2; 
//       if (ctype==0) res *= gcor02[rsigmay];      
//       if ((ctype>0)){
// 	res+=0.002;
// 	res*= gcorp[rsigmay];
//       }
//     }
//     else{
//       snoise2 = gnoise3;      
//       res     = ggg3[amp]*z+glandau3[amp]*angle2; 
//       if (ctype==0) res *= gcor02[rsigmay];
//       if ((ctype>0)){
// 	res+=0.002;
// 	res*= gcorp[rsigmay];
//       }
//     }
//   }  

//   if (ctype<0){
//     res+=0.005;
//     res*=2.4;  // overestimate error 2 times
//   }
//   res+= snoise2;
 
//   if (res<2*snoise2)
//     res = 2*snoise2;
  
//   seed->SetErrorY2(res);
//   return res;


}



Double_t AliTPCtracker::ErrZ2(AliTPCseed* seed, const AliTPCclusterMI * cl){
  //
  //
  // Use calibrated cluster error from OCDB
  //
  AliTPCClusterParam * clparam = AliTPCcalibDB::Instance()->GetClusterParam();
  //
  Float_t z = TMath::Abs(fkParam->GetZLength(0)-TMath::Abs(seed->GetZ()));
  Int_t ctype = cl->GetType();  
  Int_t    type = (cl->GetRow()<63) ? 0: (cl->GetRow()>126) ? 1:2;
  //
  Double_t angle2 = seed->GetSnp()*seed->GetSnp();
  angle2 = seed->GetTgl()*seed->GetTgl()*(1+angle2/(1-angle2)); 
  Double_t angle = TMath::Sqrt(TMath::Abs(angle2));
  Double_t errz2 = clparam->GetError0Par(1,type, z,angle);
  if (ctype<0) {
    errz2+=0.5;  // edge cluster
  }
  errz2*=errz2;
  Double_t addErr=0;
  const Double_t *errInner = AliTPCReconstructor::GetRecoParam()->GetSystematicErrorClusterInner();
  addErr=errInner[0]*TMath::Exp(-TMath::Abs((cl->GetX()-85.)/errInner[1]));
  errz2+=addErr*addErr;
  const Double_t *errCluster = AliTPCReconstructor::GetRecoParam()->GetSystematicErrorCluster();
  errz2+=errCluster[1]*errCluster[1];
  seed->SetErrorZ2(errz2);
  //
  return errz2;



//   //seed->SetErrorY2(0.1);
//   //return 0.1;
//   //calculate look-up table at the beginning
//   static Bool_t  ginit = kFALSE;
//   static Float_t gnoise1,gnoise2,gnoise3;
//   static Float_t ggg1[10000];
//   static Float_t ggg2[10000];
//   static Float_t ggg3[10000];
//   static Float_t glandau1[10000];
//   static Float_t glandau2[10000];
//   static Float_t glandau3[10000];
//   //
//   static Float_t gcor01[1000];
//   static Float_t gcor02[1000];
//   static Float_t gcorp[1000];
//   //

//   //
//   if (ginit==kFALSE){
//     for (Int_t i=1;i<1000;i++){
//       Float_t rsigma = float(i)/100.;
//       gcor02[i] = TMath::Max(0.81 +TMath::Exp(6.8*(rsigma-1.2)),0.6);
//       gcor01[i] = TMath::Max(0.72 +TMath::Exp(2.04*(rsigma-1.2)),0.6);
//       gcorp[i]  = TMath::Max(TMath::Power((rsigma+0.5),1.5),1.2);
//     }

//     //
//     for (Int_t i=3;i<10000;i++){
//       //
//       //
//       // inner sector
//       Float_t amp = float(i);
//       Float_t padlength =0.75;
//       gnoise1 = 0.0004/padlength;
//       Float_t nel     = 0.268*amp;
//       Float_t nprim   = 0.155*amp;
//       ggg1[i]          = fkParam->GetDiffT()*fkParam->GetDiffT()*(2+0.001*nel/(padlength*padlength))/nel;
//       glandau1[i]      = (2.+0.12*nprim)*0.5* (2.+nprim*nprim*0.001/(padlength*padlength))/nprim;
//       if (glandau1[i]>1) glandau1[i]=1;
//       glandau1[i]*=padlength*padlength/12.;      
//       //
//       // outer short
//       padlength =1.;
//       gnoise2   = 0.0004/padlength;
//       nel       = 0.3*amp;
//       nprim     = 0.133*amp;
//       ggg2[i]      = fkParam->GetDiffT()*fkParam->GetDiffT()*(2+0.0008*nel/(padlength*padlength))/nel;
//       glandau2[i]  = (2.+0.12*nprim)*0.5*(2.+nprim*nprim*0.001/(padlength*padlength))/nprim;
//       if (glandau2[i]>1) glandau2[i]=1;
//       glandau2[i]*=padlength*padlength/12.;
//       //
//       //
//       // outer long
//       padlength =1.5;
//       gnoise3   = 0.0004/padlength;
//       nel       = 0.3*amp;
//       nprim     = 0.133*amp;
//       ggg3[i]      = fkParam->GetDiffT()*fkParam->GetDiffT()*(2+0.0008*nel/(padlength*padlength))/nel;
//       glandau3[i]  = (2.+0.12*nprim)*0.5*(2.+nprim*nprim*0.001/(padlength*padlength))/nprim;
//       if (glandau3[i]>1) glandau3[i]=1;
//       glandau3[i]*=padlength*padlength/12.;
//       //
//     }
//     ginit = kTRUE;
//   }
//   //
//   //
//   //
//   Int_t amp = int(TMath::Abs(cl->GetQ()));  
//   if (amp>9999) {
//     seed->SetErrorY2(1.);
//     return 1.;
//   }
//   Float_t snoise2;
//   Float_t z = TMath::Abs(fkParam->GetZLength(0)-TMath::Abs(seed->GetZ()));
//   Int_t ctype = cl->GetType();  
//   Float_t padlength= GetPadPitchLength(seed->GetRow());
//   //
//   Double_t angle2 = seed->GetSnp()*seed->GetSnp();
//   //  if (angle2<0.6) angle2 = 0.6;
//   angle2 = seed->GetTgl()*seed->GetTgl()*(1+angle2/(1-angle2)); 
//   //
//   //cluster "quality"
//   Int_t rsigmaz = int(100.*cl->GetSigmaZ2()/(seed->GetCurrentSigmaZ2()));
//   Float_t res;
//   //
//   if (fSectors==fInnerSec){
//     snoise2 = gnoise1;
//     res     = ggg1[amp]*z+glandau1[amp]*angle2;     
//     if (ctype==0) res *= gcor01[rsigmaz];
//     if ((ctype>0)){
//       res+=0.002;
//       res*= gcorp[rsigmaz];
//     }
//   }
//   else {
//     if (padlength<1.1){
//       snoise2 = gnoise2;
//       res     = ggg2[amp]*z+glandau2[amp]*angle2; 
//       if (ctype==0) res *= gcor02[rsigmaz];      
//       if ((ctype>0)){
// 	res+=0.002;
// 	res*= gcorp[rsigmaz];
//       }
//     }
//     else{
//       snoise2 = gnoise3;      
//       res     = ggg3[amp]*z+glandau3[amp]*angle2; 
//       if (ctype==0) res *= gcor02[rsigmaz];
//       if ((ctype>0)){
// 	res+=0.002;
// 	res*= gcorp[rsigmaz];
//       }
//     }
//   }  

//   if (ctype<0){
//     res+=0.002;
//     res*=1.3;
//   }
//   if ((ctype<0) &&amp<70){
//     res+=0.002;
//     res*=1.3;  
//   }
//   res += snoise2;
//   if (res<2*snoise2)
//      res = 2*snoise2;
//   if (res>3) res =3;
//   seed->SetErrorZ2(res);
//   return res;
}





void AliTPCtracker::RotateToLocal(AliTPCseed *seed)
{
  //rotate to track "local coordinata
  Float_t x = seed->GetX();
  Float_t y = seed->GetY();
  Float_t ymax = x*TMath::Tan(0.5*fSectors->GetAlpha());
  
  if (y > ymax) {
    seed->SetRelativeSector((seed->GetRelativeSector()+1) % fN);
    if (!seed->Rotate(fSectors->GetAlpha())) 
      return;
  } else if (y <-ymax) {
    seed->SetRelativeSector((seed->GetRelativeSector()-1+fN) % fN);
    if (!seed->Rotate(-fSectors->GetAlpha())) 
      return;
  }   

}



//_____________________________________________________________________________
Double_t AliTPCtracker::F1old(Double_t x1,Double_t y1,
                   Double_t x2,Double_t y2,
                   Double_t x3,Double_t y3) const
{
  //-----------------------------------------------------------------
  // Initial approximation of the track curvature
  //-----------------------------------------------------------------
  Double_t d=(x2-x1)*(y3-y2)-(x3-x2)*(y2-y1);
  Double_t a=0.5*((y3-y2)*(y2*y2-y1*y1+x2*x2-x1*x1)-
                  (y2-y1)*(y3*y3-y2*y2+x3*x3-x2*x2));
  Double_t b=0.5*((x2-x1)*(y3*y3-y2*y2+x3*x3-x2*x2)-
                  (x3-x2)*(y2*y2-y1*y1+x2*x2-x1*x1));

  Double_t xr=TMath::Abs(d/(d*x1-a)), yr=d/(d*y1-b);
  if ( xr*xr+yr*yr<=0.00000000000001) return 100;
  return -xr*yr/sqrt(xr*xr+yr*yr); 
}



//_____________________________________________________________________________
Double_t AliTPCtracker::F1(Double_t x1,Double_t y1,
                   Double_t x2,Double_t y2,
                   Double_t x3,Double_t y3) const
{
  //-----------------------------------------------------------------
  // Initial approximation of the track curvature
  //-----------------------------------------------------------------
  x3 -=x1;
  x2 -=x1;
  y3 -=y1;
  y2 -=y1;
  //  
  Double_t det = x3*y2-x2*y3;
  if (TMath::Abs(det)<1e-10){
    return 100;
  }
  //
  Double_t u = 0.5* (x2*(x2-x3)+y2*(y2-y3))/det;
  Double_t x0 = x3*0.5-y3*u;
  Double_t y0 = y3*0.5+x3*u;
  Double_t c2 = 1/TMath::Sqrt(x0*x0+y0*y0);
  if (det<0) c2*=-1;
  return c2;
}


Double_t AliTPCtracker::F2(Double_t x1,Double_t y1,
                   Double_t x2,Double_t y2,
                   Double_t x3,Double_t y3) const 
{
  //-----------------------------------------------------------------
  // Initial approximation of the track curvature
  //-----------------------------------------------------------------
  x3 -=x1;
  x2 -=x1;
  y3 -=y1;
  y2 -=y1;
  //  
  Double_t det = x3*y2-x2*y3;
  if (TMath::Abs(det)<1e-10) {
    return 100;
  }
  //
  Double_t u = 0.5* (x2*(x2-x3)+y2*(y2-y3))/det;
  Double_t x0 = x3*0.5-y3*u; 
  Double_t y0 = y3*0.5+x3*u;
  Double_t c2 = 1/TMath::Sqrt(x0*x0+y0*y0);
  if (det<0) c2*=-1;
  x0+=x1;
  x0*=c2;  
  return x0;
}



//_____________________________________________________________________________
Double_t AliTPCtracker::F2old(Double_t x1,Double_t y1,
                   Double_t x2,Double_t y2,
                   Double_t x3,Double_t y3) const
{
  //-----------------------------------------------------------------
  // Initial approximation of the track curvature times center of curvature
  //-----------------------------------------------------------------
  Double_t d=(x2-x1)*(y3-y2)-(x3-x2)*(y2-y1);
  Double_t a=0.5*((y3-y2)*(y2*y2-y1*y1+x2*x2-x1*x1)-
                  (y2-y1)*(y3*y3-y2*y2+x3*x3-x2*x2));
  Double_t b=0.5*((x2-x1)*(y3*y3-y2*y2+x3*x3-x2*x2)-
                  (x3-x2)*(y2*y2-y1*y1+x2*x2-x1*x1));

  Double_t xr=TMath::Abs(d/(d*x1-a)), yr=d/(d*y1-b);
  
  return -a/(d*y1-b)*xr/sqrt(xr*xr+yr*yr);
}

//_____________________________________________________________________________
Double_t AliTPCtracker::F3(Double_t x1,Double_t y1, 
                   Double_t x2,Double_t y2,
                   Double_t z1,Double_t z2) const
{
  //-----------------------------------------------------------------
  // Initial approximation of the tangent of the track dip angle
  //-----------------------------------------------------------------
  return (z1 - z2)/sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
}


Double_t AliTPCtracker::F3n(Double_t x1,Double_t y1, 
                   Double_t x2,Double_t y2,
                   Double_t z1,Double_t z2, Double_t c) const
{
  //-----------------------------------------------------------------
  // Initial approximation of the tangent of the track dip angle
  //-----------------------------------------------------------------

  //  Double_t angle1;
  
  //angle1    =  (z1-z2)*c/(TMath::ASin(c*x1-ni)-TMath::ASin(c*x2-ni));
  //
  Double_t d  =  TMath::Sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
  if (TMath::Abs(d*c*0.5)>1) return 0;
  //  Double_t   angle2    =  TMath::ASin(d*c*0.5);
  //  Double_t   angle2    =  AliTPCFastMath::FastAsin(d*c*0.5);
  Double_t   angle2    = (d*c*0.5>0.1)? TMath::ASin(d*c*0.5): AliTPCFastMath::FastAsin(d*c*0.5);

  angle2  = (z1-z2)*c/(angle2*2.);
  return angle2;
}

Bool_t   AliTPCtracker::GetProlongation(Double_t x1, Double_t x2, Double_t x[5], Double_t &y, Double_t &z) const
{//-----------------------------------------------------------------
  // This function find proloncation of a track to a reference plane x=x2.
  //-----------------------------------------------------------------
  
  Double_t dx=x2-x1;

  if (TMath::Abs(x[4]*x1 - x[2]) >= 0.999) {   
    return kFALSE;
  }

  Double_t c1=x[4]*x1 - x[2], r1=TMath::Sqrt((1.-c1)*(1.+c1));
  Double_t c2=x[4]*x2 - x[2], r2=TMath::Sqrt((1.-c2)*(1.+c2));  
  y = x[0];
  z = x[1];
  
  Double_t dy = dx*(c1+c2)/(r1+r2);
  Double_t dz = 0;
  //
  Double_t delta = x[4]*dx*(c1+c2)/(c1*r2 + c2*r1);
  
  if (TMath::Abs(delta)>0.01){
    dz = x[3]*TMath::ASin(delta)/x[4];
  }else{
    dz = x[3]*AliTPCFastMath::FastAsin(delta)/x[4];
  }
  
  //dz = x[3]*AliTPCFastMath::FastAsin(delta)/x[4];

  y+=dy;
  z+=dz;
  
  return kTRUE;  
}

Int_t  AliTPCtracker::LoadClusters (TTree *const tree)
{
  // load clusters
  //
  fInput = tree;
  return LoadClusters();
}


Int_t  AliTPCtracker::LoadClusters(const TObjArray *arr)
{
  //
  // load clusters to the memory
  AliTPCClustersRow *clrow = new AliTPCClustersRow("AliTPCclusterMI");
  Int_t lower   = arr->LowerBound();
  Int_t entries = arr->GetEntriesFast();
  
  for (Int_t i=lower; i<entries; i++) {
    clrow = (AliTPCClustersRow*) arr->At(i);
    if(!clrow) continue;
    if(!clrow->GetArray()) continue;
    
    //  
    Int_t sec,row;
    fkParam->AdjustSectorRow(clrow->GetID(),sec,row);
    
    for (Int_t icl=0; icl<clrow->GetArray()->GetEntriesFast(); icl++){
      Transform((AliTPCclusterMI*)(clrow->GetArray()->At(icl)));
    }
    //
    if (clrow->GetArray()->GetEntriesFast()<=0) continue;
    AliTPCtrackerRow * tpcrow=0;
    Int_t left=0;
    if (sec<fkNIS*2){
      tpcrow = &(fInnerSec[sec%fkNIS][row]);    
      left = sec/fkNIS;
    }
    else{
      tpcrow = &(fOuterSec[(sec-fkNIS*2)%fkNOS][row]);
      left = (sec-fkNIS*2)/fkNOS;
    }
    if (left ==0){
      tpcrow->SetN1(clrow->GetArray()->GetEntriesFast());
      for (Int_t j=0;j<tpcrow->GetN1();++j) 
	tpcrow->SetCluster1(j, *(AliTPCclusterMI*)(clrow->GetArray()->At(j)));
    }
    if (left ==1){
      tpcrow->SetN2(clrow->GetArray()->GetEntriesFast());
      for (Int_t j=0;j<tpcrow->GetN2();++j) 
	tpcrow->SetCluster2(j, *(AliTPCclusterMI*)(clrow->GetArray()->At(j)));
    }
    clrow->GetArray()->Clear("C");
  }
  //
  delete clrow;
  LoadOuterSectors();
  LoadInnerSectors();
  return 0;
}

Int_t  AliTPCtracker::LoadClusters(const TClonesArray *arr)
{
  //
  // load clusters to the memory from one 
  // TClonesArray
  //
  AliTPCclusterMI *clust=0;
  Int_t count[72][96] = { {0} , {0} }; 

  // loop over clusters
  for (Int_t icl=0; icl<arr->GetEntriesFast(); icl++) {
    clust = (AliTPCclusterMI*)arr->At(icl);
    if(!clust) continue;
    //printf("cluster: det %d, row %d \n", clust->GetDetector(),clust->GetRow());

    // transform clusters
    Transform(clust);

    // count clusters per pad row
    count[clust->GetDetector()][clust->GetRow()]++;
  }

  // insert clusters to sectors
  for (Int_t icl=0; icl<arr->GetEntriesFast(); icl++) {
    clust = (AliTPCclusterMI*)arr->At(icl);
    if(!clust) continue;

    Int_t sec = clust->GetDetector();
    Int_t row = clust->GetRow();

    // filter overlapping pad rows needed by HLT
    if(sec<fkNIS*2) { //IROCs
     if(row == 30) continue;
    }
    else { // OROCs
      if(row == 27 || row == 76) continue;
    }

    //    Int_t left=0;
    if (sec<fkNIS*2){
      //      left = sec/fkNIS;
      fInnerSec[sec%fkNIS].InsertCluster(clust, count[sec][row], fkParam);    
    }
    else{
      //      left = (sec-fkNIS*2)/fkNOS;
      fOuterSec[(sec-fkNIS*2)%fkNOS].InsertCluster(clust, count[sec][row], fkParam);
    }
  }

  // Load functions must be called behind LoadCluster(TClonesArray*)
  // needed by HLT
  //LoadOuterSectors();
  //LoadInnerSectors();

  return 0;
}


Int_t  AliTPCtracker::LoadClusters()
{
 //
  // load clusters to the memory
  static AliTPCClustersRow *clrow= new AliTPCClustersRow("AliTPCclusterMI");
  //
  //  TTree * tree = fClustersArray.GetTree();
  AliInfo("LoadClusters()\n");

  TTree * tree = fInput;
  TBranch * br = tree->GetBranch("Segment");
  br->SetAddress(&clrow);

  // Conversion of pad, row coordinates in local tracking coords.
  // Could be skipped here; is already done in clusterfinder

  Int_t j=Int_t(tree->GetEntries());
  for (Int_t i=0; i<j; i++) {
    br->GetEntry(i);
    //  
    Int_t sec,row;
    fkParam->AdjustSectorRow(clrow->GetID(),sec,row);
    for (Int_t icl=0; icl<clrow->GetArray()->GetEntriesFast(); icl++){
      Transform((AliTPCclusterMI*)(clrow->GetArray()->At(icl)));
    }
    //
    AliTPCtrackerRow * tpcrow=0;
    Int_t left=0;
    if (sec<fkNIS*2){
      tpcrow = &(fInnerSec[sec%fkNIS][row]);    
      left = sec/fkNIS;
    }
    else{
      tpcrow = &(fOuterSec[(sec-fkNIS*2)%fkNOS][row]);
      left = (sec-fkNIS*2)/fkNOS;
    }
    if (left ==0){
      tpcrow->SetN1(clrow->GetArray()->GetEntriesFast());
      for (Int_t k=0;k<tpcrow->GetN1();++k) 
	tpcrow->SetCluster1(k, *(AliTPCclusterMI*)(clrow->GetArray()->At(k)));
    }
    if (left ==1){
      tpcrow->SetN2(clrow->GetArray()->GetEntriesFast());
      for (Int_t k=0;k<tpcrow->GetN2();++k) 
	tpcrow->SetCluster2(k, *(AliTPCclusterMI*)(clrow->GetArray()->At(k)));
    }
  }
  //
  clrow->Clear("C");
  LoadOuterSectors();
  LoadInnerSectors();

  cout << " =================================================================================================================================== " << endl;
  cout << " AliTPCReconstructor::GetRecoParam()->GetUseIonTailCorrection() =  " << AliTPCReconstructor::GetRecoParam()->GetUseIonTailCorrection() << endl;
  cout << " AliTPCReconstructor::GetRecoParam()->GetCrosstalkCorrection()  =  " << AliTPCReconstructor::GetRecoParam()->GetCrosstalkCorrection()  << endl;
  cout << " =================================================================================================================================== " << endl;

  if (AliTPCReconstructor::GetRecoParam()->GetUseIonTailCorrection()) ApplyTailCancellation();
  if (AliTPCReconstructor::GetRecoParam()->GetCrosstalkCorrection()!=0.) CalculateXtalkCorrection();
  if (AliTPCReconstructor::GetRecoParam()->GetCrosstalkCorrection()!=0.) ApplyXtalkCorrection();
  //if (AliTPCReconstructor::GetRecoParam()->GetUseOulierClusterFilter()) FilterOutlierClusters();  
  return 0;
}


void  AliTPCtracker::CalculateXtalkCorrection(){
  //
  // Calculate crosstalk estimate
  //
  const Int_t nROCs   = 72;
  const Int_t   nIterations=3;  // 
  // 0.) reset crosstalk matrix 
  //
  for (Int_t isector=0; isector<nROCs*4; isector++){  //set all ellemts of crosstalk matrix to 0 
    TMatrixD * crossTalkMatrix = (TMatrixD*)fCrossTalkSignalArray->At(isector);
    if (crossTalkMatrix)(*crossTalkMatrix)*=0;
  }
  
  //
  // 1.) Filling part -- loop over clusters
  //
  Double_t missingChargeFactor= AliTPCReconstructor::GetRecoParam()->GetCrosstalkCorrectionMissingCharge();
  for (Int_t iter=0; iter<nIterations;iter++){
    for (Int_t isector=0; isector<36; isector++){      // loop over sectors
      for (Int_t iside=0; iside<2; iside++){           // loop over sides A/C
	AliTPCtrackerSector &sector= (isector<18)?fInnerSec[isector%18]:fOuterSec[isector%18];
	Int_t nrows = sector.GetNRows();
	Int_t sec=0;
	if (isector<18) sec=isector+18*iside;
	if (isector>=18) sec=18+isector+18*iside;
	for (Int_t row = 0;row<nrows;row++){           // loop over rows       
	  //
	  //
	  Int_t wireSegmentID     = fkParam->GetWireSegment(sec,row);
	  Float_t nPadsPerSegment = (Float_t)(fkParam->GetNPadsPerSegment(wireSegmentID));
	  TMatrixD &crossTalkSignal =  *((TMatrixD*)fCrossTalkSignalArray->At(sec));
	  TMatrixD &crossTalkSignalCache =  *((TMatrixD*)fCrossTalkSignalArray->At(sec+nROCs*2));   // this is the cache value of the crosstalk from previous iteration
	  TMatrixD &crossTalkSignalBelow =  *((TMatrixD*)fCrossTalkSignalArray->At(sec+nROCs));
	  Int_t nCols=crossTalkSignal.GetNcols();
	  //
	  AliTPCtrackerRow&  tpcrow = sector[row];       
	  Int_t ncl = tpcrow.GetN1();                  // number of clusters in the row
	  if (iside>0) ncl=tpcrow.GetN2();
	  for (Int_t i=0;i<ncl;i++) {  // loop over clusters
	    AliTPCclusterMI *clXtalk= (iside>0)?(tpcrow.GetCluster2(i)):(tpcrow.GetCluster1(i));
	    
	    Int_t timeBinXtalk = clXtalk->GetTimeBin();      
	    Double_t rmsPadMin2=0.5*0.5+(fkParam->GetDiffT()*fkParam->GetDiffT())*(TMath::Abs((clXtalk->GetZ()-fkParam->GetZLength())))/(fkParam->GetPadPitchWidth(sec)*fkParam->GetPadPitchWidth(sec)); // minimal PRF width - 0.5 is the PRF in the pad units - we should et it from fkparam getters 
	    Double_t rmsTimeMin2=1+(fkParam->GetDiffL()*fkParam->GetDiffL())*(TMath::Abs((clXtalk->GetZ()-fkParam->GetZLength())))/(fkParam->GetZWidth()*fkParam->GetZWidth()); // minimal PRF width - 1 is the TRF in the time bin units - we should et it from fkParam getters
	    Double_t rmsTime2   = clXtalk->GetSigmaZ2()/(fkParam->GetZWidth()*fkParam->GetZWidth()); 
	    Double_t rmsPad2    = clXtalk->GetSigmaY2()/(fkParam->GetPadPitchWidth(sec)*fkParam->GetPadPitchWidth(sec)); 
	    if (rmsPadMin2>rmsPad2){
	      rmsPad2=rmsPadMin2;
	    }
	    if (rmsTimeMin2>rmsTime2){
	      rmsTime2=rmsTimeMin2;
	    }
	    
	    Double_t norm= 2.*TMath::Exp(-1.0/(2.*rmsTime2))+2.*TMath::Exp(-4.0/(2.*rmsTime2))+1.;
	    Double_t qTotXtalk = 0.;   
	    Double_t qTotXtalkMissing = 0.;   
	    for (Int_t itb=timeBinXtalk-2, idelta=-2; itb<=timeBinXtalk+2; itb++,idelta++) {        
	      if (itb<0 || itb>=nCols) continue;
	      Double_t missingCharge=0;
	      Double_t trf= TMath::Exp(-idelta*idelta/(2.*rmsTime2));
	      if (missingChargeFactor>0) {
		for (Int_t dpad=-2; dpad<=2; dpad++){
		  Double_t qPad =   clXtalk->GetMax()*TMath::Exp(-dpad*dpad/(2.*rmsPad2))*trf;
		  if (TMath::Nint(qPad-crossTalkSignalCache[wireSegmentID][itb])<=fkParam->GetZeroSup()){
		    missingCharge+=qPad+crossTalkSignalCache[wireSegmentID][itb];
		  }else{
		    missingCharge+=crossTalkSignalCache[wireSegmentID][itb];
		  }
		}
	      }
	      qTotXtalk = clXtalk->GetQ()*trf/norm+missingCharge*missingChargeFactor;
	      qTotXtalkMissing = missingCharge;
	      crossTalkSignal[wireSegmentID][itb]+= qTotXtalk/nPadsPerSegment; 
	      crossTalkSignalBelow[wireSegmentID][itb]+= qTotXtalkMissing/nPadsPerSegment; 
	    } // end of time bin loop
	  } // end of cluster loop	
	} // end of rows loop
      }  // end of side loop
    }    // end of sector loop
    //
    // copy crosstalk matrix to cached used for next itteration
    //
    //
    // 2.) dump the crosstalk matrices to tree for further investigation
    //     a.) to estimate fluctuation of pedestal in indiviula wire segments
    //     b.) to check correlation between regions
    //     c.) to check relative conribution of signal below threshold to crosstalk
    
    if (AliTPCReconstructor::StreamLevel()&kStreamCrosstalkMatrix) {
      for (Int_t isector=0; isector<nROCs; isector++){  //set all ellemts of crosstalk matrix to 0
	TMatrixD * crossTalkMatrix = (TMatrixD*)fCrossTalkSignalArray->At(isector);
	TMatrixD * crossTalkMatrixBelow = (TMatrixD*)fCrossTalkSignalArray->At(isector+nROCs);
	TMatrixD * crossTalkMatrixCache = (TMatrixD*)fCrossTalkSignalArray->At(isector+nROCs*2);
	TVectorD vecAll(crossTalkMatrix->GetNrows());
	TVectorD vecBelow(crossTalkMatrix->GetNrows());
	TVectorD vecCache(crossTalkMatrixCache->GetNrows());
	//
	for (Int_t itime=0; itime<crossTalkMatrix->GetNcols(); itime++){
	  for (Int_t iwire=0; iwire<crossTalkMatrix->GetNrows(); iwire++){
	    vecAll[iwire]=(*crossTalkMatrix)(iwire,itime);
	    vecBelow[iwire]=(*crossTalkMatrixBelow)(iwire,itime);
	    vecCache[iwire]=(*crossTalkMatrixCache)(iwire,itime);
	  }
	  (*fDebugStreamer)<<"crosstalkMatrix"<<
	    "iter="<<iter<<                      //iteration
	    "sector="<<isector<<                 // sector
	    "itime="<<itime<<                    // time bin index
	    "vecAll.="<<&vecAll<<                // crosstalk charge + charge below threshold
	    "vecCache.="<<&vecCache<<                // crosstalk charge + charge below threshold	  
	    "vecBelow.="<<&vecBelow<<            // crosstalk contribution from signal below threshold
	    "\n";
	}
      }
    }
    if (iter<nIterations-1) for (Int_t isector=0; isector<nROCs*2; isector++){  //set all ellemts of crosstalk matrix to 0 
      TMatrixD * crossTalkMatrix = (TMatrixD*)fCrossTalkSignalArray->At(isector);
      TMatrixD * crossTalkMatrixCache = (TMatrixD*)fCrossTalkSignalArray->At(isector+nROCs*2);
      if (crossTalkMatrix){
	(*crossTalkMatrixCache)*=0;
	(*crossTalkMatrixCache)+=(*crossTalkMatrix);
	(*crossTalkMatrix)*=0;
      }
    }      
  }


}




void    AliTPCtracker::FilterOutlierClusters(){
  //
  // filter outlier clusters  
  //
  /*
    1.)..... booking part
    nSectors=72;
    nTimeBins=fParam->Get....
    TH2F hisTime("","", sector,0,sector, nTimeBins,0,nTimeBins);
    TH2F hisPadRow("","", sector,0,sector, nPadRows,0,nPadRows);
    2.) .... filling part
    .... cluster loop { hisTime.Fill(cluster->GetDetector(),cluster->GetTimeBin()); }
    
    3.) ...filtering part 
    sector loop { calculate median,mean80 and rms80 of the nclusters per time bin; calculate median,mean80 and rms80 of the nclusters per par row; .... export values to the debug streamers - to decide which threshold to be used... }
    
    sector loop
    { disable clusters in time bins > mean+ n rms80+ offsetTime disable clusters in padRow > mean+ n rms80+ offsetPadRow // how to dislable clusters? - new bit to introduce } 
    //
    4. Disabling clusters
    
  */
  
  //
  // 1.) booking part 
  // 
  //  AliTPCcalibDB *db=AliTPCcalibDB::Instance();
  Int_t nSectors=AliTPCROC::Instance()->GetNSectors(); 
  Int_t nTimeBins= 1100; // *Bug here - we should get NTimeBins from ALTRO - Parameters not relyable
  Int_t nPadRows=(AliTPCROC::Instance()->GetNRows(0) + AliTPCROC::Instance()->GetNRows(36));
  // parameters for filtering
  const Double_t nSigmaCut=9.;           // should be in recoParam ?
  const Double_t offsetTime=100;         // should be in RecoParam ?  -
  const Double_t offsetPadRow=300;       // should be in RecoParam ?
  const Double_t offsetTimeAccept=8;     // should be in RecoParam ?  - obtained as mean +1 rms in high IR pp
  TH2F hisTime("hisSectorTime","hisSectorTime", nSectors,0,nSectors, nTimeBins,0,nTimeBins);
  TH2F hisPadRow("hisSectorRow","hisSectorRow", nSectors,0,nSectors, nPadRows,0,nPadRows);
  //
  // 2.) Filling part -- loop over clusters
  //
  for (Int_t isector=0; isector<36; isector++){      // loop over sectors
    for (Int_t iside=0; iside<2; iside++){           // loop over sides A/C
      AliTPCtrackerSector &sector= (isector<18)?fInnerSec[isector%18]:fOuterSec[isector%18];
      Int_t nrows = sector.GetNRows();
      for (Int_t row = 0;row<nrows;row++){           // loop over rows       
        AliTPCtrackerRow&  tpcrow = sector[row];       
        Int_t ncl = tpcrow.GetN1();                  // number of clusters in the row
        if (iside>0) ncl=tpcrow.GetN2();
        for (Int_t i=0;i<ncl;i++) {  // loop over clusters
          AliTPCclusterMI *cluster= (iside>0)?(tpcrow.GetCluster2(i)):(tpcrow.GetCluster1(i));
          hisTime.Fill(cluster->GetDetector(),cluster->GetTimeBin()); 
          hisPadRow.Fill(cluster->GetDetector(),cluster->GetRow()); 
	}
      } 
    } 
  } 

  //
  // 3. Filtering part
  //
  TVectorD vecTime(nTimeBins);
  TVectorD vecPadRow(nPadRows);
  TVectorD vecMedianSectorTime(nSectors);
  TVectorD vecRMSSectorTime(nSectors);
  TVectorD vecMedianSectorTimeOut6(nSectors);
  TVectorD vecMedianSectorTimeOut9(nSectors);//
  TVectorD vecMedianSectorTimeOut(nSectors);//
  TVectorD vecMedianSectorPadRow(nSectors);
  TVectorD vecRMSSectorPadRow(nSectors);
  TVectorD vecMedianSectorPadRowOut6(nSectors);
  TVectorD vecMedianSectorPadRowOut9(nSectors);
  TVectorD vecMedianSectorPadRowOut(nSectors);
  TVectorD vecSectorOut6(nSectors);
  TVectorD vecSectorOut9(nSectors);
  TMatrixD matSectorCluster(nSectors,2);
  //
  // 3.a)  median, rms calculations for hisTime 
  //
  for (Int_t isec=0; isec<nSectors; isec++){
    vecMedianSectorTimeOut6[isec]=0;
    vecMedianSectorTimeOut9[isec]=0;
    for (Int_t itime=0; itime<nTimeBins; itime++){
      vecTime[itime]=hisTime.GetBinContent(isec+1, itime+1);      
    }
    Double_t median= TMath::Mean(nTimeBins,vecTime.GetMatrixArray());
    Double_t rms= TMath::RMS(nTimeBins,vecTime.GetMatrixArray()); 
    vecMedianSectorTime[isec]=median;
    vecRMSSectorTime[isec]=rms;
    if ((AliTPCReconstructor::StreamLevel()&kStreamFilterClusterInfo)>0) AliInfo(TString::Format("Sector TimeStat: %d\t%8.0f\t%8.0f",isec,median,rms).Data());
    //
    // declare outliers
    for (Int_t itime=0; itime<nTimeBins; itime++){
      Double_t entries= hisTime.GetBinContent(isec+1, itime+1); 
      if (entries>median+6.*rms+offsetTime) {
	vecMedianSectorTimeOut6[isec]+=1;
      }
      if (entries>median+9.*rms+offsetTime) {
	vecMedianSectorTimeOut9[isec]+=1;
      }
    }
  }    
  //
  // 3.b) median, rms calculations for hisPadRow
  // 
  for (Int_t isec=0; isec<nSectors; isec++){
    vecMedianSectorPadRowOut6[isec]=0;
    vecMedianSectorPadRowOut9[isec]=0;
    for (Int_t ipadrow=0; ipadrow<nPadRows; ipadrow++){
      vecPadRow[ipadrow]=hisPadRow.GetBinContent(isec+1, ipadrow+1);      
    }
    Int_t nPadRowsSector= AliTPCROC::Instance()->GetNRows(isec);
    Double_t median= TMath::Mean(nPadRowsSector,vecPadRow.GetMatrixArray());
    Double_t rms= TMath::RMS(nPadRowsSector,vecPadRow.GetMatrixArray());
    vecMedianSectorPadRow[isec]=median;
    vecRMSSectorPadRow[isec]=rms;
    if ((AliTPCReconstructor::StreamLevel()&kStreamFilterClusterInfo)>0) AliInfo(TString::Format("Sector PadRowStat: %d\t%8.0f\t%8.0f",isec,median,rms).Data());
    //
    // declare outliers
    for (Int_t ipadrow=0; ipadrow<nPadRows; ipadrow++){
      Double_t entries= hisPadRow.GetBinContent(isec+1, ipadrow+1);
      if (entries>median+6.*rms+offsetPadRow) {
        vecMedianSectorPadRowOut6[isec]+=1;
      }
      if (entries>median+9.*rms+offsetPadRow) {
        vecMedianSectorPadRowOut9[isec]+=1;
      }
    }
  }
  //
  // 3.c) filter outlier sectors
  //
  Double_t medianSectorTime = TMath::Median(nSectors, vecTime.GetMatrixArray());
  Double_t mean69SectorTime, rms69SectorTime=0;
  AliMathBase::EvaluateUni(nSectors,  vecTime.GetMatrixArray(), mean69SectorTime,rms69SectorTime,69);
  for (Int_t isec=0; isec<nSectors; isec++){
    vecSectorOut6[isec]=0;
    vecSectorOut9[isec]=0;
    matSectorCluster(isec,0)=0;
    matSectorCluster(isec,1)=0;
    if (TMath::Abs(vecMedianSectorTime[isec])>(mean69SectorTime+6.*(rms69SectorTime+ offsetTimeAccept))) {
      vecSectorOut6[isec]=1;
    }
    if (TMath::Abs(vecMedianSectorTime[isec])>(mean69SectorTime+9.*(rms69SectorTime+ offsetTimeAccept))){
      vecSectorOut9[isec]=1;
    }
  }
  // light version of export variable
  Int_t filteredSector= vecSectorOut9.Sum();                  // light version of export variable
  Int_t filteredSectorTime= vecMedianSectorTimeOut9.Sum();
  Int_t filteredSectorPadRow= vecMedianSectorPadRowOut9.Sum();
  if (fEvent) if (fEvent->GetHeader()){
    fEvent->GetHeader()->SetTPCNoiseFilterCounter(0,TMath::Min(filteredSector,255));
    fEvent->GetHeader()->SetTPCNoiseFilterCounter(1,TMath::Min(filteredSectorTime,255));
    fEvent->GetHeader()->SetTPCNoiseFilterCounter(2,TMath::Min(filteredSectorPadRow,255));
  }
 
  //
  // 4. Disabling clusters in outlier layers
  //
  Int_t counterAll=0;
  Int_t counterOut=0;
  for (Int_t isector=0; isector<36; isector++){      // loop over sectors
    for (Int_t iside=0; iside<2; iside++){           // loop over sides A/C
      AliTPCtrackerSector &sector= (isector<18)?fInnerSec[isector%18]:fOuterSec[isector%18];
      Int_t nrows = sector.GetNRows();
      for (Int_t row = 0;row<nrows;row++){           // loop over rows       
        AliTPCtrackerRow&  tpcrow = sector[row];       
        Int_t ncl = tpcrow.GetN1();                  // number of clusters in the row
        if (iside>0) ncl=tpcrow.GetN2();
        for (Int_t i=0;i<ncl;i++) {  // loop over clusters
          AliTPCclusterMI *cluster= (iside>0)?(tpcrow.GetCluster2(i)):(tpcrow.GetCluster1(i));
	  Double_t medianTime=vecMedianSectorTime[cluster->GetDetector()];
	  Double_t medianPadRow=vecMedianSectorPadRow[cluster->GetDetector()];
	  Double_t rmsTime=vecRMSSectorTime[cluster->GetDetector()];
	  Double_t rmsPadRow=vecRMSSectorPadRow[cluster->GetDetector()];
	  Int_t entriesPadRow=hisPadRow.GetBinContent(cluster->GetDetector()+1, cluster->GetRow()+1);
	  Int_t entriesTime=hisTime.GetBinContent(cluster->GetDetector()+1, cluster->GetTimeBin()+1);
	  Bool_t isOut=kFALSE;
	  if (vecSectorOut9[cluster->GetDetector()]>0.5) {
	    isOut=kTRUE;
	  }
	  
	  if (entriesTime>medianTime+nSigmaCut*rmsTime+offsetTime) {
	    isOut=kTRUE;
	    vecMedianSectorTimeOut[cluster->GetDetector()]++;
	  }
	  if (entriesPadRow>medianPadRow+nSigmaCut*rmsPadRow+offsetPadRow) {
	    isOut=kTRUE;
	    vecMedianSectorPadRowOut[cluster->GetDetector()]++;
	  }
	  counterAll++;
	  matSectorCluster(cluster->GetDetector(),0)+=1;
	  if (isOut){
	    cluster->Disable();
	    counterOut++;
	    matSectorCluster(cluster->GetDetector(),1)+=1;
	  }
	}
      }
    }
  }
  for (Int_t isec=0; isec<nSectors; isec++){
    if ((AliTPCReconstructor::StreamLevel()&kStreamFilterClusterInfo)>0) AliInfo(TString::Format("Sector Stat: %d\t%8.0f\t%8.0f",isec,matSectorCluster(isec,1),matSectorCluster(isec,0)).Data());
  }
  //
  // dump info to streamer - for later tuning of cuts
  //
  if ((AliTPCReconstructor::StreamLevel()&kStreamFilterClusterInfo)>0) {  // stream TPC data ouliers filtering infomation
    AliLog::Flush();
    AliInfo(TString::Format("Cluster counter: (%d/%d) (Filtered/All)",counterOut,counterAll).Data());
    for (Int_t iSec=0; iSec<nSectors; iSec++){
      if (vecSectorOut9[iSec]>0 ||  matSectorCluster(iSec,1)>0) {
	AliInfo(TString::Format("Filtered sector\t%d",iSec).Data());
	Double_t vecMedTime =TMath::Median(72,vecMedianSectorTime.GetMatrixArray());
	Double_t vecMedPadRow =TMath::Median(72,vecMedianSectorPadRow.GetMatrixArray());
	Double_t vecMedCluster=(counterAll-counterOut)/72;
	AliInfo(TString::Format("VecMedianSectorTime\t(%4.4f/%4.4f/%4.4f)",       vecMedianSectorTimeOut[iSec],vecMedianSectorTime[iSec],vecMedTime).Data());
	AliInfo(TString::Format("VecMedianSectorPadRow\t(%4.4f/%4.4f/%4.4f)",     vecMedianSectorPadRowOut[iSec],vecMedianSectorPadRow[iSec],vecMedPadRow).Data());
	AliInfo(TString::Format("MatSectorCluster\t(%4.4f/%4.4f/%4.4f)\n",          matSectorCluster(iSec,1), matSectorCluster(iSec,0),  vecMedCluster).Data());
	AliLog::Flush();
      }
    }
    AliLog::Flush();
    Int_t eventNr = fEvent->GetEventNumberInFile();
    (*fDebugStreamer)<<"filterClusterInfo"<<
      // minimal set variables for the ESDevent
      "eventNr="<<eventNr<<
      "counterAll="<<counterAll<<
      "counterOut="<<counterOut<<
      "matSectotCluster.="<<&matSectorCluster<<                   // 
      //
      "filteredSector="<<filteredSector<<                        //  counter filtered sectors                   
      "filteredSectorTime="<<filteredSectorTime<<                //  counter filtered time bins
      "filteredSectorPadRow="<<filteredSectorPadRow<<            //  counter filtered pad-rows
      // per sector outlier information
      "medianSectorTime="<<medianSectorTime<<                    // median number of clusters per sector/timebin
      "mean69SectorTime="<<mean69SectorTime<<                    // LTM statistic  mean of clusters per sector/timebin
      "rms69SectorTime="<<rms69SectorTime<<                      // LTM statistic  RMS of clusters per sector/timebin
      "vecSectorOut6.="<<&vecSectorOut6<<                        // flag array sector  - 6 sigma +accept margin outlier
      "vecSectorOut9.="<<&vecSectorOut9<<                        // flag array sector  - 9 sigma + accept margin outlier
      // per sector/timebin outlier detection
      "vecMedianSectorTime.="<<&vecMedianSectorTime<<
      "vecRMSSectorTime.="<<&vecRMSSectorTime<<
      "vecMedianSectorTimeOut6.="<<&vecMedianSectorTimeOut6<<
      "vecMedianSectorTimeOut9.="<<&vecMedianSectorTimeOut9<<
      "vecMedianSectorTimeOut0.="<<&vecMedianSectorTimeOut<<
      // per sector/pad-row outlier detection
      "vecMedianSectorPadRow.="<<&vecMedianSectorPadRow<<
      "vecRMSSectorPadRow.="<<&vecRMSSectorPadRow<<
      "vecMedianSectorPadRowOut6.="<<&vecMedianSectorPadRowOut6<<
      "vecMedianSectorPadRowOut9.="<<&vecMedianSectorPadRowOut9<<
      "vecMedianSectorPadRowOut9.="<<&vecMedianSectorPadRowOut<<
      "\n";
    ((*fDebugStreamer)<<"filterClusterInfo").GetTree()->Write();
    fDebugStreamer->GetFile()->Flush();
  }
}

void AliTPCtracker::UnloadClusters()
{
  //
  // unload clusters from the memory
  //
  Int_t nrows = fOuterSec->GetNRows();
  for (Int_t sec = 0;sec<fkNOS;sec++)
    for (Int_t row = 0;row<nrows;row++){
      AliTPCtrackerRow*  tpcrow = &(fOuterSec[sec%fkNOS][row]);
      //      if (tpcrow){
      //	if (tpcrow->fClusters1) delete []tpcrow->fClusters1; 
      //	if (tpcrow->fClusters2) delete []tpcrow->fClusters2; 
      //}
      tpcrow->ResetClusters();
    }
  //
  nrows = fInnerSec->GetNRows();
  for (Int_t sec = 0;sec<fkNIS;sec++)
    for (Int_t row = 0;row<nrows;row++){
      AliTPCtrackerRow*  tpcrow = &(fInnerSec[sec%fkNIS][row]);
      //if (tpcrow){
      //	if (tpcrow->fClusters1) delete []tpcrow->fClusters1; 
      //if (tpcrow->fClusters2) delete []tpcrow->fClusters2; 
      //}
      tpcrow->ResetClusters();
    }

  return ;
}

void AliTPCtracker::FillClusterArray(TObjArray* array) const{
  //
  // Filling cluster to the array - For visualization purposes
  //
  Int_t nrows=0;
  nrows = fOuterSec->GetNRows();
  for (Int_t sec = 0;sec<fkNOS;sec++)
    for (Int_t row = 0;row<nrows;row++){
      AliTPCtrackerRow*  tpcrow = &(fOuterSec[sec%fkNOS][row]);
      if (!tpcrow) continue;
      for (Int_t icl = 0;icl<tpcrow->GetN();icl++){
	array->AddLast((TObject*)((*tpcrow)[icl]));
      }
    } 
  nrows = fInnerSec->GetNRows();
  for (Int_t sec = 0;sec<fkNIS;sec++)
    for (Int_t row = 0;row<nrows;row++){
      AliTPCtrackerRow*  tpcrow = &(fInnerSec[sec%fkNIS][row]);
      if (!tpcrow) continue;
      for (Int_t icl = 0;icl<tpcrow->GetN();icl++){
	array->AddLast((TObject*)(*tpcrow)[icl]);
      }
    }
}


void   AliTPCtracker::Transform(AliTPCclusterMI * cluster){
  //
  // transformation
  //
  AliTPCcalibDB * calibDB = AliTPCcalibDB::Instance();
  AliTPCTransform *transform = calibDB->GetTransform() ;
  if (!transform) {
    AliFatal("Tranformations not in calibDB");
    return;
  }
  transform->SetCurrentRecoParam((AliTPCRecoParam*)AliTPCReconstructor::GetRecoParam());
  Double_t x[3]={static_cast<Double_t>(cluster->GetRow()),static_cast<Double_t>(cluster->GetPad()),static_cast<Double_t>(cluster->GetTimeBin())};
  Int_t i[1]={cluster->GetDetector()};
  transform->Transform(x,i,0,1);  
  //  if (cluster->GetDetector()%36>17){
  //  x[1]*=-1;
  //}

  //
  // in debug mode  check the transformation
  //
  if ((AliTPCReconstructor::StreamLevel()&kStreamTransform)>0) { 
    Float_t gx[3];
    cluster->GetGlobalXYZ(gx);
    Int_t event = (fEvent==NULL)? 0: fEvent->GetEventNumberInFile();
    TTreeSRedirector &cstream = *fDebugStreamer;
    cstream<<"Transform"<<  // needed for debugging of the cluster transformation, resp. used for later visualization 
      "event="<<event<<
      "x0="<<x[0]<<
      "x1="<<x[1]<<
      "x2="<<x[2]<<
      "gx0="<<gx[0]<<
      "gx1="<<gx[1]<<
      "gx2="<<gx[2]<<
      "Cl.="<<cluster<<
      "\n"; 
  }
  cluster->SetX(x[0]);
  cluster->SetY(x[1]);
  cluster->SetZ(x[2]);
  // The old stuff:
  //
  // 
  //
  //if (!fkParam->IsGeoRead()) fkParam->ReadGeoMatrices();
  if (AliTPCReconstructor::GetRecoParam()->GetUseSectorAlignment() && (!calibDB->HasAlignmentOCDB())){
    TGeoHMatrix  *mat = fkParam->GetClusterMatrix(cluster->GetDetector());
    //TGeoHMatrix  mat;
    Double_t pos[3]= {cluster->GetX(),cluster->GetY(),cluster->GetZ()};
    Double_t posC[3]={cluster->GetX(),cluster->GetY(),cluster->GetZ()};
    if (mat) mat->LocalToMaster(pos,posC);
    else{
      // chack Loading of Geo matrices from GeoManager - TEMPORARY FIX
    }
    cluster->SetX(posC[0]);
    cluster->SetY(posC[1]);
    cluster->SetZ(posC[2]);
  }
}

void  AliTPCtracker::ApplyXtalkCorrection(){
  //
  // ApplyXtalk correction 
  // Loop over all clusters
  //      add to each cluster signal corresponding to common Xtalk mode for given time bin at given wire segment
  // cluster loop
  for (Int_t isector=0; isector<36; isector++){  //loop tracking sectors
    for (Int_t iside=0; iside<2; iside++){       // loop over sides A/C
      AliTPCtrackerSector &sector= (isector<18)?fInnerSec[isector%18]:fOuterSec[isector%18];
      Int_t nrows     = sector.GetNRows();       
      for (Int_t row = 0;row<nrows;row++){           // loop over rows       
	AliTPCtrackerRow&  tpcrow = sector[row];     // row object   
	Int_t ncl = tpcrow.GetN1();                  // number of clusters in the row
	if (iside>0) ncl=tpcrow.GetN2();
	Int_t xSector=0;    // sector number in the TPC convention 0-72
	if (isector<18){  //if IROC
	  xSector=isector+(iside>0)*18;
	}else{
	  xSector=isector+18;  // isector -18 +36   
	  if (iside>0) xSector+=18;
	}	
	TMatrixD &crossTalkMatrix= *((TMatrixD*)fCrossTalkSignalArray->At(xSector));
	Int_t wireSegmentID     = fkParam->GetWireSegment(xSector,row);
	for (Int_t i=0;i<ncl;i++) {
	  AliTPCclusterMI *cluster= (iside>0)?(tpcrow.GetCluster2(i)):(tpcrow.GetCluster1(i));
	  Int_t iTimeBin=TMath::Nint(cluster->GetTimeBin());
	  Double_t xTalk= crossTalkMatrix[wireSegmentID][iTimeBin];
	  cluster->SetMax(cluster->GetMax()+xTalk);
	  const Double_t kDummy=4;
	  Double_t sumxTalk=xTalk*kDummy; // should be calculated via time response function
	  cluster->SetQ(cluster->GetQ()+sumxTalk);


          if ((AliTPCReconstructor::StreamLevel()&kStreamXtalk)>0) {  // flag: stream crosstalk correctio as applied to cluster
            TTreeSRedirector &cstream = *fDebugStreamer;
            if (gRandom->Rndm() > 0.){
              cstream<<"Xtalk"<<
                "isector=" << isector <<               // sector [0,36]
                "iside=" << iside <<                   // side A or C
                "row=" << row <<                       // padrow
                "i=" << i <<                           // index of the cluster 
                "xSector=" << xSector <<               // sector [0,72] 
                "wireSegmentID=" << wireSegmentID <<   // anode wire segment id [0,10] 
                "iTimeBin=" << iTimeBin <<             // timebin of the corrected cluster 
                "xTalk=" << xTalk <<                   // Xtalk contribution added to Qmax
                "sumxTalk=" << sumxTalk <<             // Xtalk contribution added to Qtot (roughly 3*Xtalk) 
                "cluster.=" << cluster <<              // corrected cluster object 
                "\n";
            }
          }// dump the results to the debug streamer if in debug mode





	}
      }
    }
  }
}

void  AliTPCtracker::ApplyTailCancellation(){
  //
  // Correct the cluster charge for the ion tail effect 
  // The TimeResponse function accessed via  AliTPCcalibDB (TPC/Calib/IonTail)
  //

  // Retrieve
  TObjArray *ionTailArr = (TObjArray*)AliTPCcalibDB::Instance()->GetIonTailArray();
  if (!ionTailArr) {AliFatal("TPC - Missing IonTail OCDB object");}
  TObject *rocFactorIROC  = ionTailArr->FindObject("factorIROC");
  TObject *rocFactorOROC  = ionTailArr->FindObject("factorOROC");   
  Float_t factorIROC      = (atof(rocFactorIROC->GetTitle()));
  Float_t factorOROC      = (atof(rocFactorOROC->GetTitle()));

  // find the number of clusters for the whole TPC (nclALL)
  Int_t nclALL=0;
  for (Int_t isector=0; isector<36; isector++){
    AliTPCtrackerSector &sector= (isector<18)?fInnerSec[isector%18]:fOuterSec[isector%18];
    nclALL += sector.GetNClInSector(0);
    nclALL += sector.GetNClInSector(1);
  }

  // start looping over all clusters 
  for (Int_t iside=0; iside<2; iside++){    // loop over sides
    //
    //
    for (Int_t secType=0; secType<2; secType++){  //loop over inner or outer sector
      // cache experimantal tuning factor for the different chamber type 
      const Float_t ampfactor = (secType==0)?factorIROC:factorOROC;
      std::cout << " ampfactor = " << ampfactor << std::endl;
      //
      for (Int_t sec = 0;sec<fkNOS;sec++){        //loop overs sectors
        //
        //
        // Cache time response functions and their positons to COG of the cluster        
        TGraphErrors ** graphRes   = new TGraphErrors *[20];
        Float_t * indexAmpGraphs   = new Float_t[20];      
        for (Int_t icache=0; icache<20; icache++) 
        {
          graphRes[icache]       = NULL;
          indexAmpGraphs[icache] = 0;
        }
        /////////////////////////////  --> position fo sie loop
        if (!AliTPCcalibDB::Instance()->GetTailcancelationGraphs(sec+36*secType+18*iside,graphRes,indexAmpGraphs))
        {
          continue;
        }
        
        AliTPCtrackerSector &sector= (secType==0)?fInnerSec[sec]:fOuterSec[sec];  
        Int_t nrows     = sector.GetNRows();                                       // number of rows
        Int_t nclSector = sector.GetNClInSector(iside);                            // ncl per sector to be used for debugging

        for (Int_t row = 0;row<nrows;row++){           // loop over rows

          AliTPCtrackerRow&  tpcrow = sector[row];     // row object   
          Int_t ncl = tpcrow.GetN1();                  // number of clusters in the row
          if (iside>0) ncl=tpcrow.GetN2();
        
          // Order clusters in time for the proper correction of ion tail
          Float_t qTotArray[ncl];                      // arrays to be filled with modified Qtot and Qmax values in order to avoid float->int conversion  
          Float_t qMaxArray[ncl];
          Int_t sortedClusterIndex[ncl];
          Float_t sortedClusterTimeBin[ncl];
          TObjArray *rowClusterArray = new TObjArray(ncl);  // cache clusters for each row  
          for (Int_t i=0;i<ncl;i++) 
          {
            qTotArray[i]=0;
            qMaxArray[i]=0;
            sortedClusterIndex[i]=i;
            AliTPCclusterMI *rowcl= (iside>0)?(tpcrow.GetCluster2(i)):(tpcrow.GetCluster1(i));
            if (rowcl) {
              rowClusterArray->AddAt(rowcl,i);
            } else {
              rowClusterArray->RemoveAt(i);
            }
            // Fill the timebin info to the array in order to sort wrt tb
            if (!rowcl) {
	      sortedClusterTimeBin[i]=0.0;
	    } else {
            sortedClusterTimeBin[i] = rowcl->GetTimeBin();
	    }

          } 
	  TMath::Sort(ncl,sortedClusterTimeBin,sortedClusterIndex,kFALSE);       // sort clusters in time
     
          // Main cluster correction loops over clusters
          for (Int_t icl0=0; icl0<ncl;icl0++){    // first loop over clusters

            AliTPCclusterMI *cl0= static_cast<AliTPCclusterMI*>(rowClusterArray->At(sortedClusterIndex[icl0]));
            
            if (!cl0) continue;
            Int_t nclPad=0;                       
            for (Int_t icl1=0; icl1<ncl;icl1++){  // second loop over clusters	   
              AliTPCclusterMI *cl1= static_cast<AliTPCclusterMI*>(rowClusterArray->At(sortedClusterIndex[icl1]));
	      if (!cl1) continue;
	      if (TMath::Abs(cl0->GetPad()-cl1->GetPad())>4) continue;           // no contribution if far away in pad direction
              if (cl0->GetTimeBin()<= cl1->GetTimeBin()) continue;               // no contibution to the tail if later
              if (TMath::Abs(cl1->GetTimeBin()-cl0->GetTimeBin())>600) continue; // out of the range of response function

              if (TMath::Abs(cl0->GetPad()-cl1->GetPad())<4) nclPad++;           // count ncl for every pad for debugging
            
              // Get the correction values for Qmax and Qtot and find total correction for a given cluster
              Double_t ionTailMax=0.;  
              Double_t ionTailTotal=0.;  
              GetTailValue(ampfactor,ionTailMax,ionTailTotal,graphRes,indexAmpGraphs,cl0,cl1);
              ionTailMax=TMath::Abs(ionTailMax);
              ionTailTotal=TMath::Abs(ionTailTotal);
              qTotArray[icl0]+=ionTailTotal;
              qMaxArray[icl0]+=ionTailMax;

              // Dump some info for debugging while clusters are being corrected
              if ((AliTPCReconstructor::StreamLevel()&kStreamIonTail)>0) {  // flag: stream ion tail correction  as applied to cluster
                TTreeSRedirector &cstream = *fDebugStreamer;
                if (gRandom->Rndm() > 0.999){
                  cstream<<"IonTail"<<
                      "cl0.="         <<cl0          <<   // cluster 0 (to be corrected)
                      "cl1.="         <<cl1          <<   // cluster 1 (previous cluster)
                      "ionTailTotal=" <<ionTailTotal <<   // ion Tail from cluster 1 contribution to cluster0
                      "ionTailMax="   <<ionTailMax   <<   // ion Tail from cluster 1 contribution to cluster0 
                      "\n";
                }
              }// dump the results to the debug streamer if in debug mode
            
            }//end of second loop over clusters
            
            // Set corrected values of the corrected cluster          
            cl0->SetQ(TMath::Nint(Float_t(cl0->GetQ())+Float_t(qTotArray[icl0])));
            cl0->SetMax(TMath::Nint(Float_t(cl0->GetMax())+qMaxArray[icl0]));
          
            // Dump some info for debugging after clusters are corrected 
            if ((AliTPCReconstructor::StreamLevel()&kStreamIonTail)>0) {
              TTreeSRedirector &cstream = *fDebugStreamer;
              if (gRandom->Rndm() > 0.999){
              cstream<<"IonTailCorrected"<<
                  "cl0.="                     << cl0              <<   // cluster 0 with huge Qmax
                  "ionTailTotalPerCluster="   << qTotArray[icl0]  <<
                  "ionTailMaxPerCluster="     << qMaxArray[icl0]  <<
                  "nclALL="                   << nclALL           <<
                  "nclSector="                << nclSector        <<
                  "nclRow="                   << ncl              <<
                  "nclPad="                   << nclPad           <<
                  "row="                      << row              <<
                  "sector="                   << sec              <<
                  "icl0="                     << icl0             <<
                  "\n";
              }
            }// dump the results to the debug streamer if in debug mode
          
          }//end of first loop over cluster
          delete rowClusterArray;
        }//end of loop over rows
        for (int i=0; i<20; i++) delete graphRes[i];
        delete [] graphRes;
        delete [] indexAmpGraphs;
      
      }//end of loop over sectors
    }//end of loop over IROC/OROC
  }// end of side loop
}
//_____________________________________________________________________________
void AliTPCtracker::GetTailValue(Float_t ampfactor,Double_t &ionTailMax, Double_t &ionTailTotal,TGraphErrors **graphRes,Float_t *indexAmpGraphs,AliTPCclusterMI *cl0,AliTPCclusterMI *cl1){

  //
  // Function in order to calculate the amount of the correction to be added for a given cluster, return values are ionTailTaoltal and ionTailMax
  // Parameters:
  // cl0 -  cluster to be modified
  // cl1 -  source cluster ion tail of this cluster will be added to the cl0 (accroding time and pad response function)
  // 
  const Double_t kMinPRF    = 0.5;                           // minimal PRF width
  ionTailTotal              = 0.;                            // correction value to be added to Qtot of cl0
  ionTailMax                = 0.;                            // correction value to be added to Qmax of cl0

  Float_t qTot0             =  cl0->GetQ();                  // cl0 Qtot info
  Float_t qTot1             =  cl1->GetQ();                  // cl1 Qtot info
  Int_t sectorPad           =  cl1->GetDetector();           // sector number
  Int_t padcl0              =  TMath::Nint(cl0->GetPad());   // pad0
  Int_t padcl1              =  TMath::Nint(cl1->GetPad());   // pad1
  Float_t padWidth          = (sectorPad < 36)?0.4:0.6;      // pad width in cm
  const Int_t deltaTimebin  =  TMath::Nint(TMath::Abs(cl1->GetTimeBin()-cl0->GetTimeBin()))+12;  //distance between pads of cl1 and cl0 increased by 12 bins
  Double_t rmsPad1          = (cl1->GetSigmaY2()==0)?kMinPRF:(TMath::Sqrt(cl1->GetSigmaY2())/padWidth);
  Double_t rmsPad0          = (cl0->GetSigmaY2()==0)?kMinPRF:(TMath::Sqrt(cl0->GetSigmaY2())/padWidth);
  
   
  
  Double_t sumAmp1=0.;
  for (Int_t idelta =-2; idelta<=2;idelta++){
    sumAmp1+=TMath::Exp(-idelta*idelta/(2*rmsPad1));
  }

  Double_t sumAmp0=0.;
  for (Int_t idelta =-2; idelta<=2;idelta++){
    sumAmp0+=TMath::Exp(-idelta*idelta/(2*rmsPad0));
  }

  // Apply the correction  -->   cl1 corrects cl0 (loop over cl1's pads and find which pads of cl0 are going to be corrected)
  Int_t padScan=2;      // +-2 pad-timebin window will be scanned
  for (Int_t ipad1=padcl1-padScan; ipad1<=padcl1+padScan; ipad1++) {
    //
    //
    Float_t  deltaPad1  = TMath::Abs(cl1->GetPad()-(Float_t)ipad1);
    Double_t amp1       = (TMath::Exp(-(deltaPad1*deltaPad1)/(2*rmsPad1)))/sumAmp1;  // normalized pad response function
    Float_t qTotPad1    = amp1*qTot1;                                               // used as a factor to multipliy the response function
      
    // find closest value of cl1 to COG (among the time response functions' amplitude array --> to select proper t.r.f.)
    Int_t ampIndex = 0;
    Float_t diffAmp  = TMath::Abs(deltaPad1-indexAmpGraphs[0]);
    for (Int_t j=0;j<20;j++) {
      if (diffAmp > TMath::Abs(deltaPad1-indexAmpGraphs[j]) && indexAmpGraphs[j]!=0)
        {
          diffAmp  = TMath::Abs(deltaPad1-indexAmpGraphs[j]);
          ampIndex = j;
        }
    }
    if (!graphRes[ampIndex]) continue;
    if (deltaTimebin+2 >= graphRes[ampIndex]->GetN()) continue;
    if (graphRes[ampIndex]->GetY()[deltaTimebin+2]>=0) continue;
     
    for (Int_t ipad0=padcl0-padScan; ipad0<=padcl0+padScan; ipad0++) {
      //
      //
      if (ipad1!=ipad0) continue;                                     // check if ipad1 channel sees ipad0 channel, if not no correction to be applied.
      
      Float_t deltaPad0  = TMath::Abs(cl0->GetPad()-(Float_t)ipad0);
      Double_t amp0      = (TMath::Exp(-(deltaPad0*deltaPad0)/(2*rmsPad0)))/sumAmp0;  // normalized pad resp function
      Float_t qMaxPad0   = amp0*qTot0;
           
      // Add 5 timebin range contribution around the max peak (-+2 tb window)
      for (Int_t itb=deltaTimebin-2; itb<=deltaTimebin+2; itb++) {

        if (itb<0) continue; 
        if (itb>=graphRes[ampIndex]->GetN()) continue;
       
        // calculate contribution to qTot
        Float_t tailCorr =  TMath::Abs((qTotPad1*ampfactor)*(graphRes[ampIndex])->GetY()[itb]);
        if (ipad1!=padcl0) { 
          ionTailTotal += TMath::Min(qMaxPad0,tailCorr);   // for side pad
        } else {             
          ionTailTotal += tailCorr;                        // for center pad
        }
        // calculate contribution to qMax
        if (itb == deltaTimebin && ipad1 == padcl0) ionTailMax += tailCorr;   
        
      } // end of tb correction loop which is applied over 5 tb range

    } // end of cl0 loop
  } // end of cl1 loop
  
}

//_____________________________________________________________________________
Int_t AliTPCtracker::LoadOuterSectors() {
  //-----------------------------------------------------------------
  // This function fills outer TPC sectors with clusters.
  //-----------------------------------------------------------------
  Int_t nrows = fOuterSec->GetNRows();
  UInt_t index=0;
  for (Int_t sec = 0;sec<fkNOS;sec++)
    for (Int_t row = 0;row<nrows;row++){
      AliTPCtrackerRow*  tpcrow = &(fOuterSec[sec%fkNOS][row]);  
      Int_t sec2 = sec+2*fkNIS;
      //left
      Int_t ncl = tpcrow->GetN1();
      while (ncl--) {
	AliTPCclusterMI *c= (tpcrow->GetCluster1(ncl));
	index=(((sec2<<8)+row)<<16)+ncl;
	tpcrow->InsertCluster(c,index);
      }
      //right
      ncl = tpcrow->GetN2();
      while (ncl--) {
	AliTPCclusterMI *c= (tpcrow->GetCluster2(ncl));
	index=((((sec2+fkNOS)<<8)+row)<<16)+ncl;
	tpcrow->InsertCluster(c,index);
      }
      //
      // write indexes for fast acces
      //
      for (Int_t i=0;i<510;i++)
	tpcrow->SetFastCluster(i,-1);
      for (Int_t i=0;i<tpcrow->GetN();i++){
        Int_t zi = Int_t((*tpcrow)[i]->GetZ()+255.);
	tpcrow->SetFastCluster(zi,i);  // write index
      }
      Int_t last = 0;
      for (Int_t i=0;i<510;i++){
	if (tpcrow->GetFastCluster(i)<0)
	  tpcrow->SetFastCluster(i,last);
	else
	  last = tpcrow->GetFastCluster(i);
      }
    }  
  fN=fkNOS;
  fSectors=fOuterSec;
  return 0;
}


//_____________________________________________________________________________
Int_t  AliTPCtracker::LoadInnerSectors() {
  //-----------------------------------------------------------------
  // This function fills inner TPC sectors with clusters.
  //-----------------------------------------------------------------
  Int_t nrows = fInnerSec->GetNRows();
  UInt_t index=0;
  for (Int_t sec = 0;sec<fkNIS;sec++)
    for (Int_t row = 0;row<nrows;row++){
      AliTPCtrackerRow*  tpcrow = &(fInnerSec[sec%fkNIS][row]);
      //
      //left
      Int_t ncl = tpcrow->GetN1();
      while (ncl--) {
	AliTPCclusterMI *c= (tpcrow->GetCluster1(ncl));
	index=(((sec<<8)+row)<<16)+ncl;
	tpcrow->InsertCluster(c,index);
      }
      //right
      ncl = tpcrow->GetN2();
      while (ncl--) {
	AliTPCclusterMI *c= (tpcrow->GetCluster2(ncl));
	index=((((sec+fkNIS)<<8)+row)<<16)+ncl;
	tpcrow->InsertCluster(c,index);
      }
      //
      // write indexes for fast acces
      //
      for (Int_t i=0;i<510;i++)
	tpcrow->SetFastCluster(i,-1);
      for (Int_t i=0;i<tpcrow->GetN();i++){
        Int_t zi = Int_t((*tpcrow)[i]->GetZ()+255.);
	tpcrow->SetFastCluster(zi,i);  // write index
      }
      Int_t last = 0;
      for (Int_t i=0;i<510;i++){
	if (tpcrow->GetFastCluster(i)<0)
	  tpcrow->SetFastCluster(i,last);
	else
	  last = tpcrow->GetFastCluster(i);
      }

    }  
   
  fN=fkNIS;
  fSectors=fInnerSec;
  return 0;
}



//_________________________________________________________________________
AliTPCclusterMI *AliTPCtracker::GetClusterMI(Int_t index) const {
  //--------------------------------------------------------------------
  //       Return pointer to a given cluster
  //--------------------------------------------------------------------
  if (index<0) return 0; // no cluster
  Int_t sec=(index&0xff000000)>>24; 
  Int_t row=(index&0x00ff0000)>>16; 
  Int_t ncl=(index&0x00007fff)>>00;

  const AliTPCtrackerRow * tpcrow=0;
  TClonesArray * clrow =0;

  if (sec<0 || sec>=fkNIS*4) {
    AliWarning(Form("Wrong sector %d",sec));
    return 0x0;
  }

  if (sec<fkNIS*2){
    AliTPCtrackerSector& tracksec = fInnerSec[sec%fkNIS];
    if (tracksec.GetNRows()<=row) return 0;
    tpcrow = &(tracksec[row]);
    if (tpcrow==0) return 0;

    if (sec<fkNIS) {
      if (tpcrow->GetN1()<=ncl) return 0;
      clrow = tpcrow->GetClusters1();
    }
    else {
      if (tpcrow->GetN2()<=ncl) return 0;
      clrow = tpcrow->GetClusters2();
    }
  }
  else {
    AliTPCtrackerSector& tracksec = fOuterSec[(sec-fkNIS*2)%fkNOS];
    if (tracksec.GetNRows()<=row) return 0;
    tpcrow = &(tracksec[row]);
    if (tpcrow==0) return 0;

    if (sec-2*fkNIS<fkNOS) {
      if (tpcrow->GetN1()<=ncl) return 0;
      clrow = tpcrow->GetClusters1();
    }
    else {
      if (tpcrow->GetN2()<=ncl) return 0;
      clrow = tpcrow->GetClusters2();
    }
  }

  return (AliTPCclusterMI*)clrow->At(ncl);
  
}



Int_t AliTPCtracker::FollowToNext(AliTPCseed& t, Int_t nr) {
  //-----------------------------------------------------------------
  // This function tries to find a track prolongation to next pad row
  //-----------------------------------------------------------------
  //
  Double_t  x= GetXrow(nr), ymax=GetMaxY(nr);
  //
  //
  AliTPCclusterMI *cl=0;
  Int_t tpcindex= t.GetClusterIndex2(nr);
  //
  // update current shape info every 5 pad-row
  //  if ( (nr%5==0) || t.GetNumberOfClusters()<2 || (t.fCurrentSigmaY2<0.0001) ){
    GetShape(&t,nr);    
    //}
  //  
  if (fIteration>0 && tpcindex>=-1){  //if we have already clusters 
    //        
    if (tpcindex==-1) return 0; //track in dead zone
    if (tpcindex >= 0){     //
      cl = t.GetClusterPointer(nr);
      //if (cl==0) cl = GetClusterMI(tpcindex);
      if (!cl) cl = GetClusterMI(tpcindex);
      t.SetCurrentClusterIndex1(tpcindex); 
    }
    if (cl){      
      Int_t relativesector = ((tpcindex&0xff000000)>>24)%18;  // if previously accepted cluster in different sector
      Float_t angle = relativesector*fSectors->GetAlpha()+fSectors->GetAlphaShift();
      //
      if (angle<-TMath::Pi()) angle += 2*TMath::Pi();
      if (angle>=TMath::Pi()) angle -= 2*TMath::Pi();
      
      if (TMath::Abs(angle-t.GetAlpha())>0.001){
	Double_t rotation = angle-t.GetAlpha();
	t.SetRelativeSector(relativesector);
	if (!t.Rotate(rotation)) {
          t.SetClusterIndex(nr, t.GetClusterIndex(nr) | 0x8000);
          return 0;
        }	
      }
      if (!t.PropagateTo(x)) {
        t.SetClusterIndex(nr, t.GetClusterIndex(nr) | 0x8000);
        return 0;
      }
      //
      t.SetCurrentCluster(cl); 
      t.SetRow(nr);
      Int_t accept = AcceptCluster(&t,t.GetCurrentCluster());
      if ((tpcindex&0x8000)==0) accept =0;
      if (accept<3) { 
	//if founded cluster is acceptible
	if (cl->IsUsed(11)) {  // id cluster is shared inrease uncertainty
	  t.SetErrorY2(t.GetErrorY2()+0.03);
	  t.SetErrorZ2(t.GetErrorZ2()+0.03); 
	  t.SetErrorY2(t.GetErrorY2()*3);
	  t.SetErrorZ2(t.GetErrorZ2()*3); 
	}
	t.SetNFoundable(t.GetNFoundable()+1);
	UpdateTrack(&t,accept);
	return 1;
      }
      else { // Remove old cluster from track
	t.SetClusterIndex(nr, -3);
	t.SetClusterPointer(nr, 0);
      }
    }
  }
  if (TMath::Abs(t.GetSnp())>AliTPCReconstructor::GetMaxSnpTracker()) return 0;  // cut on angle
  if (fIteration>1 && IsFindable(t)){
    // not look for new cluster during refitting    
    t.SetNFoundable(t.GetNFoundable()+1);
    return 0;
  }
  //
  UInt_t index=0;
  //  if (TMath::Abs(t.GetSnp())>0.95 || TMath::Abs(x*t.GetC()-t.GetEta())>0.95) return 0;// patch 28 fev 06
  if (!t.PropagateTo(x)) {
    if (fIteration==0) t.SetRemoval(10);
    return 0;
  }
  Double_t y = t.GetY(); 
  if (TMath::Abs(y)>ymax){
    if (y > ymax) {
      t.SetRelativeSector((t.GetRelativeSector()+1) % fN);
      if (!t.Rotate(fSectors->GetAlpha())) 
	return 0;
    } else if (y <-ymax) {
      t.SetRelativeSector((t.GetRelativeSector()-1+fN) % fN);
      if (!t.Rotate(-fSectors->GetAlpha())) 
	return 0;
    }
    if (!t.PropagateTo(x)) {
      if (fIteration==0) t.SetRemoval(10);
      return 0;
    }
    y = t.GetY();
  }
  //
  Double_t z=t.GetZ();
  //

  if (!IsActive(t.GetRelativeSector(),nr)) {
    t.SetInDead(kTRUE);
    t.SetClusterIndex2(nr,-1); 
    return 0;
  }
  //AliInfo(Form("A - Sector%d phi %f - alpha %f", t.fRelativeSector,y/x, t.GetAlpha()));
  Bool_t isActive  = IsActive(t.GetRelativeSector(),nr);
  Bool_t isActive2 = (nr>=fInnerSec->GetNRows()) ? fOuterSec[t.GetRelativeSector()][nr-fInnerSec->GetNRows()].GetN()>0:fInnerSec[t.GetRelativeSector()][nr].GetN()>0;
  
  if (!isActive || !isActive2) return 0;

  const AliTPCtrackerRow &krow=GetRow(t.GetRelativeSector(),nr);
  if ( (t.GetSigmaY2()<0) || t.GetSigmaZ2()<0) return 0;
  Double_t  roady  =1.;
  Double_t  roadz = 1.;
  //
  if (TMath::Abs(TMath::Abs(y)-ymax)<krow.GetDeadZone()){
    t.SetInDead(kTRUE);
    t.SetClusterIndex2(nr,-1); 
    return 0;
  } 
  else
    {
      if (IsFindable(t))
	  //      if (TMath::Abs(z)<(AliTPCReconstructor::GetCtgRange()*x+10) && TMath::Abs(z)<fkParam->GetZLength(0) && (TMath::Abs(t.GetSnp())<AliTPCReconstructor::GetMaxSnpTracker())) 
	t.SetNFoundable(t.GetNFoundable()+1);
      else
	return 0;
    }   
  //calculate 
  if (krow) {
    //    cl = krow.FindNearest2(y+10.,z,roady,roadz,index);    
    cl = krow.FindNearest2(y,z,roady,roadz,index);    
    if (cl) t.SetCurrentClusterIndex1(krow.GetIndex(index));       
  }  
  if (cl) {
    t.SetCurrentCluster(cl); 
    t.SetRow(nr);
    if (fIteration==2&&cl->IsUsed(10)) return 0; 
    Int_t accept = AcceptCluster(&t,t.GetCurrentCluster());
    if (fIteration==2&&cl->IsUsed(11)) {
      t.SetErrorY2(t.GetErrorY2()+0.03);
      t.SetErrorZ2(t.GetErrorZ2()+0.03); 
      t.SetErrorY2(t.GetErrorY2()*3);
      t.SetErrorZ2(t.GetErrorZ2()*3); 
    }
    /*    
    if (t.fCurrentCluster->IsUsed(10)){
      //
      //     

      t.fNShared++;
      if (t.fNShared>0.7*t.GetNumberOfClusters()) {
	t.fRemoval =10;
	return 0;
      }
    }
    */
    if (accept<3) UpdateTrack(&t,accept);

  } else {  
    if ( fIteration==0 && t.GetNFoundable()*0.5 > t.GetNumberOfClusters()) t.SetRemoval(10);
    
  }
  return 1;
}



//_________________________________________________________________________
Bool_t AliTPCtracker::GetTrackPoint(Int_t index, AliTrackPoint &p ) const
{
  // Get track space point by index
  // return false in case the cluster doesn't exist
  AliTPCclusterMI *cl = GetClusterMI(index);
  if (!cl) return kFALSE;
  Int_t sector = (index&0xff000000)>>24;
  //  Int_t row = (index&0x00ff0000)>>16;
  Float_t xyz[3];
  //  xyz[0] = fkParam->GetPadRowRadii(sector,row);
  xyz[0] = cl->GetX();
  xyz[1] = cl->GetY();
  xyz[2] = cl->GetZ();
  Float_t sin,cos;
  fkParam->AdjustCosSin(sector,cos,sin);
  Float_t x = cos*xyz[0]-sin*xyz[1];
  Float_t y = cos*xyz[1]+sin*xyz[0];
  Float_t cov[6];
  Float_t sigmaY2 = 0.027*cl->GetSigmaY2();
  if (sector < fkParam->GetNInnerSector()) sigmaY2 *= 2.07;
  Float_t sigmaZ2 = 0.066*cl->GetSigmaZ2();
  if (sector < fkParam->GetNInnerSector()) sigmaZ2 *= 1.77;
  cov[0] = sin*sin*sigmaY2;
  cov[1] = -sin*cos*sigmaY2;
  cov[2] = 0.;
  cov[3] = cos*cos*sigmaY2;
  cov[4] = 0.;
  cov[5] = sigmaZ2;
  p.SetXYZ(x,y,xyz[2],cov);
  AliGeomManager::ELayerID iLayer;
  Int_t idet;
  if (sector < fkParam->GetNInnerSector()) {
    iLayer = AliGeomManager::kTPC1;
    idet = sector;
  }
  else {
    iLayer = AliGeomManager::kTPC2;
    idet = sector - fkParam->GetNInnerSector();
  }
  UShort_t volid = AliGeomManager::LayerToVolUID(iLayer,idet);
  p.SetVolumeID(volid);
  return kTRUE;
}



Int_t AliTPCtracker::UpdateClusters(AliTPCseed& t,  Int_t nr) {
  //-----------------------------------------------------------------
  // This function tries to find a track prolongation to next pad row
  //-----------------------------------------------------------------
  t.SetCurrentCluster(0);
  t.SetCurrentClusterIndex1(-3);   
   
  Double_t xt=t.GetX();
  Int_t     row = GetRowNumber(xt)-1; 
  Double_t  ymax= GetMaxY(nr);

  if (row < nr) return 1; // don't prolongate if not information until now -
//   if (TMath::Abs(t.GetSnp())>0.9 && t.GetNumberOfClusters()>40. && fIteration!=2) {
//     t.fRemoval =10;
//     return 0;  // not prolongate strongly inclined tracks
//   } 
//   if (TMath::Abs(t.GetSnp())>0.95) {
//     t.fRemoval =10;
//     return 0;  // not prolongate strongly inclined tracks
//   }// patch 28 fev 06

  Double_t x= GetXrow(nr);
  Double_t y,z;
  //t.PropagateTo(x+0.02);
  //t.PropagateTo(x+0.01);
  if (!t.PropagateTo(x)){
    return 0;
  }
  //
  y=t.GetY();
  z=t.GetZ();

  if (TMath::Abs(y)>ymax){
    if (y > ymax) {
      t.SetRelativeSector((t.GetRelativeSector()+1) % fN);
      if (!t.Rotate(fSectors->GetAlpha())) 
	return 0;
    } else if (y <-ymax) {
      t.SetRelativeSector((t.GetRelativeSector()-1+fN) % fN);
      if (!t.Rotate(-fSectors->GetAlpha())) 
	return 0;
    }
    //    if (!t.PropagateTo(x)){
    //  return 0;
    //}
    return 1;
    //y = t.GetY();    
  }
  //
  if (TMath::Abs(t.GetSnp())>AliTPCReconstructor::GetMaxSnpTracker()) return 0;

  if (!IsActive(t.GetRelativeSector(),nr)) {
    t.SetInDead(kTRUE);
    t.SetClusterIndex2(nr,-1); 
    return 0;
  }
  //AliInfo(Form("A - Sector%d phi %f - alpha %f", t.fRelativeSector,y/x, t.GetAlpha()));

  AliTPCtrackerRow &krow=GetRow(t.GetRelativeSector(),nr);

  if (TMath::Abs(TMath::Abs(y)-ymax)<krow.GetDeadZone()){
    t.SetInDead(kTRUE);
    t.SetClusterIndex2(nr,-1); 
    return 0;
  } 
  else
    {

      //      if (TMath::Abs(t.GetZ())<(AliTPCReconstructor::GetCtgRange()*t.GetX()+10) && (TMath::Abs(t.GetSnp())<AliTPCReconstructor::GetMaxSnpTracker())) 
      if (IsFindable(t)) t.SetNFoundable(t.GetNFoundable()+1);
      else
	return 0;      
    }

  // update current
  if ( (nr%2==0) || t.GetNumberOfClusters()<2){
    //    t.fCurrentSigmaY = GetSigmaY(&t);
    //t.fCurrentSigmaZ = GetSigmaZ(&t);
    GetShape(&t,nr);
  }
    
  AliTPCclusterMI *cl=0;
  Int_t index=0;
  //
  Double_t roady = 1.;
  Double_t roadz = 1.;
  //

  if (!cl){
    index = t.GetClusterIndex2(nr);    
    if ( (index >= 0) && (index&0x8000)==0){
      cl = t.GetClusterPointer(nr);
      if ( (cl==0) && (index >= 0)) cl = GetClusterMI(index);
      t.SetCurrentClusterIndex1(index);
      if (cl) {
	t.SetCurrentCluster(cl);
	return 1;
      }
    }
  }

  //  if (index<0) return 0;
  UInt_t uindex = TMath::Abs(index);

  if (krow) {    
    //cl = krow.FindNearest2(y+10,z,roady,roadz,uindex);      
    cl = krow.FindNearest2(y,z,roady,roadz,uindex);      
  }

  if (cl) t.SetCurrentClusterIndex1(krow.GetIndex(uindex));   
  t.SetCurrentCluster(cl);

  return 1;
}


Int_t AliTPCtracker::FollowToNextCluster(AliTPCseed & t, Int_t nr) {
  //-----------------------------------------------------------------
  // This function tries to find a track prolongation to next pad row
  //-----------------------------------------------------------------

  //update error according neighborhoud

  if (t.GetCurrentCluster()) {
    t.SetRow(nr); 
    Int_t accept = AcceptCluster(&t,t.GetCurrentCluster());
    
    if (t.GetCurrentCluster()->IsUsed(10)){
      //
      //
      //  t.fErrorZ2*=2;
      //  t.fErrorY2*=2;
      t.SetNShared(t.GetNShared()+1);
      if (t.GetNShared()>0.7*t.GetNumberOfClusters()) {
	t.SetRemoval(10);
	return 0;
      }
    }   
    if (fIteration>0) accept = 0;
    if (accept<3)  UpdateTrack(&t,accept);  
 
  } else {
    if (fIteration==0){
      if ( t.GetNumberOfClusters()>18 && ( (t.GetSigmaY2()+t.GetSigmaZ2())>0.16)) t.SetRemoval(10);      
      if ( t.GetNumberOfClusters()>18 && t.GetChi2()/t.GetNumberOfClusters()>6 ) t.SetRemoval(10);      

      if (( (t.GetNFoundable()*0.5 > t.GetNumberOfClusters()) || t.GetNoCluster()>15)) t.SetRemoval(10);
    }
  }
  return 1;
}



//_____________________________________________________________________________
Int_t AliTPCtracker::FollowProlongation(AliTPCseed& t, Int_t rf, Int_t step, Bool_t fromSeeds) {
  //-----------------------------------------------------------------
  // This function tries to find a track prolongation.
  //-----------------------------------------------------------------
  Double_t xt=t.GetX();
  //
  Double_t alpha=t.GetAlpha();
  if (alpha > 2.*TMath::Pi()) alpha -= 2.*TMath::Pi();  
  if (alpha < 0.            ) alpha += 2.*TMath::Pi();  
  //
  t.SetRelativeSector(Int_t(alpha/fSectors->GetAlpha()+0.0001)%fN);
    
  Int_t first = GetRowNumber(xt);
  if (!fromSeeds)
    first -= step;
  if (first < 0)
    first = 0;
  for (Int_t nr= first; nr>=rf; nr-=step) {
    // update kink info
    if (t.GetKinkIndexes()[0]>0){
      for (Int_t i=0;i<3;i++){
	Int_t index = t.GetKinkIndexes()[i];
	if (index==0) break;
	if (index<0) continue;
	//
	AliKink * kink = (AliKink*)fEvent->GetKink(index-1);
	if (!kink){
	  printf("PROBLEM\n");
	}
	else{
	  Int_t kinkrow = kink->GetTPCRow0()+2+Int_t(0.5/(0.05+kink->GetAngle(2)));
	  if (kinkrow==nr){
	    AliExternalTrackParam paramd(t);
	    kink->SetDaughter(paramd);
	    kink->SetStatus(2,5);
	    kink->Update();
	  }
	}
      }
    }

    if (nr==80) t.UpdateReference();
    if (nr<fInnerSec->GetNRows()) 
      fSectors = fInnerSec;
    else
      fSectors = fOuterSec;
    if (FollowToNext(t,nr)==0) 
      if (!t.IsActive()) 
	return 0;
    
  }   
  return 1;
}






Int_t AliTPCtracker::FollowBackProlongation(AliTPCseed& t, Int_t rf, Bool_t fromSeeds) {
  //-----------------------------------------------------------------
  // This function tries to find a track prolongation.
  //-----------------------------------------------------------------
  //
  Double_t xt=t.GetX();  
  Double_t alpha=t.GetAlpha();
  if (alpha > 2.*TMath::Pi()) alpha -= 2.*TMath::Pi();  
  if (alpha < 0.            ) alpha += 2.*TMath::Pi();  
  t.SetRelativeSector(Int_t(alpha/fSectors->GetAlpha()+0.0001)%fN);
    
  Int_t first = t.GetFirstPoint();
  Int_t ri = GetRowNumber(xt); 
  if (!fromSeeds)
    ri += 1;

  if (first<ri) first = ri;
  //
  if (first<0) first=0;
  for (Int_t nr=first; nr<=rf; nr++) {
    //    if ( (TMath::Abs(t.GetSnp())>0.95)) break;//patch 28 fev 06
    if (t.GetKinkIndexes()[0]<0){
      for (Int_t i=0;i<3;i++){
	Int_t index = t.GetKinkIndexes()[i];
	if (index==0) break;
	if (index>0) continue;
	index = TMath::Abs(index);
	AliKink * kink = (AliKink*)fEvent->GetKink(index-1);
	if (!kink){
	  printf("PROBLEM\n");
	}
	else{
	  Int_t kinkrow = kink->GetTPCRow0()-2-Int_t(0.5/(0.05+kink->GetAngle(2)));
	  if (kinkrow==nr){
	    AliExternalTrackParam paramm(t);
	    kink->SetMother(paramm);
	    kink->SetStatus(2,1);
	    kink->Update();
	  }
	}
      }      
    }
    //
    if (nr<fInnerSec->GetNRows()) 
      fSectors = fInnerSec;
    else
      fSectors = fOuterSec;

    FollowToNext(t,nr);                                                             
  }   
  return 1;
}




   
Float_t AliTPCtracker::OverlapFactor(AliTPCseed * s1, AliTPCseed * s2, Int_t &sum1, Int_t & sum2)
{
  // overlapping factor
  //
  sum1=0;
  sum2=0;
  Int_t sum=0;
  //
  Float_t dz2 =(s1->GetZ() - s2->GetZ());
  dz2*=dz2;  

  Float_t dy2 =TMath::Abs((s1->GetY() - s2->GetY()));
  dy2*=dy2;
  Float_t distance = TMath::Sqrt(dz2+dy2);
  if (distance>4.) return 0; // if there are far away  - not overlap - to reduce combinatorics
 
  //  Int_t offset =0;
  Int_t firstpoint = TMath::Min(s1->GetFirstPoint(),s2->GetFirstPoint());
  Int_t lastpoint = TMath::Max(s1->GetLastPoint(),s2->GetLastPoint());
  if (lastpoint>160) 
    lastpoint =160;
  if (firstpoint<0) 
    firstpoint = 0;
  if (firstpoint>lastpoint) {
    firstpoint =lastpoint;
    //    lastpoint  =160;
  }
    
  
  for (Int_t i=firstpoint-1;i<lastpoint+1;i++){
    if (s1->GetClusterIndex2(i)>0) sum1++;
    if (s2->GetClusterIndex2(i)>0) sum2++;
    if (s1->GetClusterIndex2(i)==s2->GetClusterIndex2(i) && s1->GetClusterIndex2(i)>0) {
      sum++;
    }
  }
  if (sum<5) return 0;

  Float_t summin = TMath::Min(sum1+1,sum2+1);
  Float_t ratio = (sum+1)/Float_t(summin);
  return ratio;
}

void  AliTPCtracker::SignShared(AliTPCseed * s1, AliTPCseed * s2)
{
  // shared clusters
  //
  Float_t thetaCut = 0.2;//+10.*TMath::Sqrt(s1->GetSigmaTglZ()+ s2->GetSigmaTglZ());
  if (TMath::Abs(s1->GetTgl()-s2->GetTgl())>thetaCut) return;
  Float_t minCl = TMath::Min(s1->GetNumberOfClusters(),s2->GetNumberOfClusters());
  Int_t cutN0 = TMath::Max(5,TMath::Nint(0.1*minCl));
  
  //
  Int_t sumshared=0;
  //
  //Int_t firstpoint = TMath::Max(s1->GetFirstPoint(),s2->GetFirstPoint());
  //Int_t lastpoint = TMath::Min(s1->GetLastPoint(),s2->GetLastPoint());
  Int_t firstpoint = 0;
  Int_t lastpoint = 160;
  //
  //  if (firstpoint>=lastpoint-5) return;;

  for (Int_t i=firstpoint;i<lastpoint;i++){
    //    if ( (s1->GetClusterIndex2(i)&0xFFFF8FFF)==(s2->GetClusterIndex2(i)&0xFFFF8FFF) && s1->GetClusterIndex2(i)>0) {
    if ( (s1->GetClusterIndex2(i))==(s2->GetClusterIndex2(i)) && s1->GetClusterIndex2(i)>0) {
      sumshared++;
    }
  }
  if (sumshared>cutN0){
    // sign clusters
    //
    for (Int_t i=firstpoint;i<lastpoint;i++){
      //      if ( (s1->GetClusterIndex2(i)&0xFFFF8FFF)==(s2->GetClusterIndex2(i)&0xFFFF8FFF) && s1->GetClusterIndex2(i)>0) {
      if ( (s1->GetClusterIndex2(i))==(s2->GetClusterIndex2(i)) && s1->GetClusterIndex2(i)>0) {
	AliTPCTrackerPoint *p1  = s1->GetTrackPoint(i);
	AliTPCTrackerPoint *p2  = s2->GetTrackPoint(i);; 
	if (s1->IsActive()&&s2->IsActive()){
	  p1->SetShared(kTRUE);
	  p2->SetShared(kTRUE);
	}	
      }
    }
  }
  //  
  if (sumshared>cutN0){
    for (Int_t i=0;i<4;i++){
      if (s1->GetOverlapLabel(3*i)==0){
	s1->SetOverlapLabel(3*i,  s2->GetLabel());
	s1->SetOverlapLabel(3*i+1,sumshared);
	s1->SetOverlapLabel(3*i+2,s2->GetUniqueID());
	break;
      }	
    }
    for (Int_t i=0;i<4;i++){
      if (s2->GetOverlapLabel(3*i)==0){
	s2->SetOverlapLabel(3*i,  s1->GetLabel());
	s2->SetOverlapLabel(3*i+1,sumshared);
	s2->SetOverlapLabel(3*i+2,s1->GetUniqueID());
	break;
      }	
    }    
  }
}

void  AliTPCtracker::SignShared(TObjArray * arr)
{
  //
  //sort trackss according sectors
  //  
  for (Int_t i=0; i<arr->GetEntriesFast(); i++) {
    AliTPCseed *pt=(AliTPCseed*)arr->UncheckedAt(i);    
    if (!pt) continue;
    //if (pt) RotateToLocal(pt);
    pt->SetSort(0);
  }
  arr->UnSort();
  arr->Sort();  // sorting according relative sectors
  arr->Expand(arr->GetEntries());
  //
  //
  Int_t nseed=arr->GetEntriesFast();
  for (Int_t i=0; i<nseed; i++) {
    AliTPCseed *pt=(AliTPCseed*)arr->UncheckedAt(i);    
    if (!pt) continue;
    for (Int_t j=0;j<12;j++){
      pt->SetOverlapLabel(j,0);
    }
  }
  for (Int_t i=0; i<nseed; i++) {
    AliTPCseed *pt=(AliTPCseed*)arr->UncheckedAt(i);    
    if (!pt) continue;
    if (pt->GetRemoval()>10) continue;
    for (Int_t j=i+1; j<nseed; j++){
      AliTPCseed *pt2=(AliTPCseed*)arr->UncheckedAt(j);
      if (TMath::Abs(pt->GetRelativeSector()-pt2->GetRelativeSector())>1) continue;
      //      if (pt2){
      if (pt2->GetRemoval()<=10) {
	//if ( TMath::Abs(pt->GetRelativeSector()-pt2->GetRelativeSector())>0) break;
	SignShared(pt,pt2);
      }
    }  
  }
}


void AliTPCtracker::SortTracks(TObjArray * arr, Int_t mode) const
{
  //
  //sort tracks in array according mode criteria
  Int_t nseed = arr->GetEntriesFast();    
  for (Int_t i=0; i<nseed; i++) {
    AliTPCseed *pt=(AliTPCseed*)arr->UncheckedAt(i);    
    if (!pt) {
      continue;
    }
    pt->SetSort(mode);
  }
  arr->UnSort();
  arr->Sort();
}


void AliTPCtracker::RemoveUsed2(TObjArray * arr, Float_t factor1,  Float_t factor2, Int_t minimal)
{
  //
  // Loop over all tracks and remove overlaped tracks (with lower quality)
  // Algorithm:
  //    1. Unsign clusters
  //    2. Sort tracks according quality
  //       Quality is defined by the number of cluster between first and last points 
  //       
  //    3. Loop over tracks - decreasing quality order
  //       a.) remove - If the fraction of shared cluster less than factor (1- n or 2) 
  //       b.) remove - If the minimal number of clusters less than minimal and not ITS
  //       c.) if track accepted - sign clusters
  //
  //Called in - AliTPCtracker::Clusters2Tracks()
  //          - AliTPCtracker::PropagateBack()
  //          - AliTPCtracker::RefitInward()
  //
  // Arguments:
  //   factor1 - factor for constrained
  //   factor2 -        for non constrained tracks 
  //            if (Float_t(shared+1)/Float_t(found+1)>factor) - DELETE
  //
  UnsignClusters();
  //
  Int_t nseed = arr->GetEntriesFast();  
  Float_t * quality = new Float_t[nseed];
  Int_t   * indexes = new Int_t[nseed];
  Int_t good =0;
  //
  //
  for (Int_t i=0; i<nseed; i++) {
    AliTPCseed *pt=(AliTPCseed*)arr->UncheckedAt(i);    
    if (!pt){
      quality[i]=-1;
      continue;
    }
    pt->UpdatePoints();    //select first last max dens points
    Float_t * points = pt->GetPoints();
    if (points[3]<0.8) quality[i] =-1;
    quality[i] = (points[2]-points[0])+pt->GetNumberOfClusters();
    //prefer high momenta tracks if overlaps
    quality[i] *= TMath::Sqrt(TMath::Abs(pt->Pt())+0.5); 
  }
  TMath::Sort(nseed,quality,indexes);
  //
  //
  for (Int_t itrack=0; itrack<nseed; itrack++) {
    Int_t trackindex = indexes[itrack];
    AliTPCseed *pt=(AliTPCseed*)arr->UncheckedAt(trackindex);   
    if (!pt) continue;
    //
    if (quality[trackindex]<0){
      MarkSeedFree( arr->RemoveAt(trackindex) );
      continue;
    }
    //
    //
    Int_t first = Int_t(pt->GetPoints()[0]);
    Int_t last  = Int_t(pt->GetPoints()[2]);
    Double_t factor = (pt->GetBConstrain()) ? factor1: factor2;
    //
    Int_t found,foundable,shared;
    pt->GetClusterStatistic(first,last, found, foundable,shared,kFALSE); // better to get statistic in "high-dens"  region do't use full track as in line bellow
    //    pt->GetClusterStatistic(0,160, found, foundable,shared,kFALSE);
    Bool_t itsgold =kFALSE;
    if (pt->GetESD()){
      Int_t dummy[12];
      if (pt->GetESD()->GetITSclusters(dummy)>4) itsgold= kTRUE;
    }
    if (!itsgold){
      //
      if (Float_t(shared+1)/Float_t(found+1)>factor){
	if (pt->GetKinkIndexes()[0]!=0) continue;  //don't remove tracks  - part of the kinks
	if( (AliTPCReconstructor::StreamLevel()&kStreamRemoveUsed)>0){ // flag:stream  information about TPC tracks which were descarded (double track removal)
	  TTreeSRedirector &cstream = *fDebugStreamer;
	  cstream<<"RemoveUsed"<<
	    "iter="<<fIteration<<
	    "pt.="<<pt<<
	    "\n";
	}
	MarkSeedFree( arr->RemoveAt(trackindex) );
	continue;
      }      
      if (pt->GetNumberOfClusters()<50&&(found-0.5*shared)<minimal){  //remove short tracks
	if (pt->GetKinkIndexes()[0]!=0) continue;  //don't remove tracks  - part of the kinks
	if( (AliTPCReconstructor::StreamLevel()&kStreamRemoveShort)>0){ // flag:stream  information about TPC tracks which were discarded (short track removal)
	  TTreeSRedirector &cstream = *fDebugStreamer;
	  cstream<<"RemoveShort"<<
	    "iter="<<fIteration<<
	    "pt.="<<pt<<
	    "\n";
	}
	MarkSeedFree( arr->RemoveAt(trackindex) );
	continue;
      }
    }

    good++;
    //if (sharedfactor>0.4) continue;
    if (pt->GetKinkIndexes()[0]>0) continue;
    //Remove tracks with undefined properties - seems
    if (pt->GetSigmaY2()<kAlmost0) continue; // ? what is the origin ? 
    //
    for (Int_t i=first; i<last; i++) {
      Int_t index=pt->GetClusterIndex2(i);
      // if (index<0 || index&0x8000 ) continue;
      if (index<0 || index&0x8000 ) continue;
      AliTPCclusterMI *c= pt->GetClusterPointer(i);        
      if (!c) continue;
      c->Use(10);  
    }    
  }
  fNtracks = good;
  if (fDebug>0){
    Info("RemoveUsed","\n*****\nNumber of good tracks after shared removal\t%d\n",fNtracks);
  }
  delete []quality;
  delete []indexes;
}

void AliTPCtracker::DumpClusters(Int_t iter, TObjArray *trackArray) 
{
  //
  // Dump clusters after reco
  // signed and unsigned cluster can be visualized   
  // 1. Unsign all cluster
  // 2. Sign all used clusters
  // 3. Dump clusters
  UnsignClusters();
  Int_t nseed = trackArray->GetEntries();
  for (Int_t i=0; i<nseed; i++){
    AliTPCseed *pt=(AliTPCseed*)trackArray->UncheckedAt(i);    
    if (!pt) {
      continue;
    }    
    Bool_t isKink=pt->GetKinkIndex(0)!=0;
    for (Int_t j=0; j<160; ++j) {
      Int_t index=pt->GetClusterIndex2(j);
      if (index<0) continue;
      AliTPCclusterMI *c= pt->GetClusterPointer(j);
      if (!c) continue;
      if (isKink) c->Use(100);   // kink
      c->Use(10);                // by default usage 10
    }
  }
  //
  Int_t eventNr = fEvent->GetEventNumberInFile();

  for (Int_t sec=0;sec<fkNIS;sec++){
    for (Int_t row=0;row<fInnerSec->GetNRows();row++){
      TClonesArray *cla = fInnerSec[sec][row].GetClusters1();
      for (Int_t icl =0;icl< fInnerSec[sec][row].GetN1();icl++){    
	AliTPCclusterMI* cl = (AliTPCclusterMI*)cla->At(icl);
	Float_t gx[3];	cl->GetGlobalXYZ(gx);
	(*fDebugStreamer)<<"clDump"<< 
	  "eventNr="<<eventNr<<
	  "iter="<<iter<<
	  "cl.="<<cl<<      
	  "gx0="<<gx[0]<<
	  "gx1="<<gx[1]<<
	  "gx2="<<gx[2]<<
	  "\n";
      }
      cla = fInnerSec[sec][row].GetClusters2();
      for (Int_t icl =0;icl< fInnerSec[sec][row].GetN2();icl++){
	AliTPCclusterMI* cl = (AliTPCclusterMI*)cla->At(icl);
	Float_t gx[3];	cl->GetGlobalXYZ(gx);
	(*fDebugStreamer)<<"clDump"<< 
	  "eventNr="<<eventNr<<
	  "iter="<<iter<<
	  "cl.="<<cl<<
	  "gx0="<<gx[0]<<
	  "gx1="<<gx[1]<<
	  "gx2="<<gx[2]<<
	  "\n";
      }
    }
  }
  
  for (Int_t sec=0;sec<fkNOS;sec++){
    for (Int_t row=0;row<fOuterSec->GetNRows();row++){
      TClonesArray *cla = fOuterSec[sec][row].GetClusters1();
      for (Int_t icl =0;icl< fOuterSec[sec][row].GetN1();icl++){
	Float_t gx[3];	
	AliTPCclusterMI* cl = (AliTPCclusterMI*) cla->At(icl);
	cl->GetGlobalXYZ(gx);
	(*fDebugStreamer)<<"clDump"<< 
	  "eventNr="<<eventNr<<
	  "iter="<<iter<<
	  "cl.="<<cl<<
	  "gx0="<<gx[0]<<
	  "gx1="<<gx[1]<<
	  "gx2="<<gx[2]<<
	  "\n";      
      }
      cla = fOuterSec[sec][row].GetClusters2();
      for (Int_t icl =0;icl< fOuterSec[sec][row].GetN2();icl++){
	Float_t gx[3];	
	AliTPCclusterMI* cl = (AliTPCclusterMI*) cla->At(icl);
	cl->GetGlobalXYZ(gx);
	(*fDebugStreamer)<<"clDump"<< 
	  "eventNr="<<eventNr<<
	  "iter="<<iter<<
	  "cl.="<<cl<<
	  "gx0="<<gx[0]<<
	  "gx1="<<gx[1]<<
	  "gx2="<<gx[2]<<
	  "\n";      
      }
    }
  }
  
}
void AliTPCtracker::UnsignClusters() 
{
  //
  // loop over all clusters and unsign them
  //
  
  for (Int_t sec=0;sec<fkNIS;sec++){
    for (Int_t row=0;row<fInnerSec->GetNRows();row++){
      TClonesArray *cla = fInnerSec[sec][row].GetClusters1();
      for (Int_t icl =0;icl< fInnerSec[sec][row].GetN1();icl++)
	//	if (cl[icl].IsUsed(10)) 	
	((AliTPCclusterMI*) cla->At(icl))->Use(-1);
      cla = fInnerSec[sec][row].GetClusters2();
      for (Int_t icl =0;icl< fInnerSec[sec][row].GetN2();icl++)
	//if (cl[icl].IsUsed(10)) 	
	((AliTPCclusterMI*) cla->At(icl))->Use(-1);
    }
  }
  
  for (Int_t sec=0;sec<fkNOS;sec++){
    for (Int_t row=0;row<fOuterSec->GetNRows();row++){
      TClonesArray *cla = fOuterSec[sec][row].GetClusters1();
      for (Int_t icl =0;icl< fOuterSec[sec][row].GetN1();icl++)
	//if (cl[icl].IsUsed(10)) 	
	((AliTPCclusterMI*) cla->At(icl))->Use(-1);
      cla = fOuterSec[sec][row].GetClusters2();
      for (Int_t icl =0;icl< fOuterSec[sec][row].GetN2();icl++)
	//if (cl[icl].IsUsed(10)) 	
	((AliTPCclusterMI*) cla->At(icl))->Use(-1);
    }
  }
  
}



void AliTPCtracker::SignClusters(const TObjArray * arr, Float_t fnumber, Float_t fdensity)
{
  //
  //sign clusters to be "used"
  //
  // snumber and sdensity sign number of sigmas - bellow mean value to be accepted
  // loop over "primaries"
  
  Float_t sumdens=0;
  Float_t sumdens2=0;
  Float_t sumn   =0;
  Float_t sumn2  =0;
  Float_t sumchi =0;
  Float_t sumchi2 =0;

  Float_t sum    =0;

  TStopwatch timer;
  timer.Start();

  Int_t nseed = arr->GetEntriesFast();
  for (Int_t i=0; i<nseed; i++) {
    AliTPCseed *pt=(AliTPCseed*)arr->UncheckedAt(i);    
    if (!pt) {
      continue;
    }    
    if (!(pt->IsActive())) continue;
    Float_t dens = pt->GetNumberOfClusters()/Float_t(pt->GetNFoundable());
    if ( (dens>0.7) && (pt->GetNumberOfClusters()>70)){
      sumdens += dens;
      sumdens2+= dens*dens;
      sumn    += pt->GetNumberOfClusters();
      sumn2   += pt->GetNumberOfClusters()*pt->GetNumberOfClusters();
      Float_t chi2 = pt->GetChi2()/pt->GetNumberOfClusters();
      if (chi2>5) chi2=5;
      sumchi  +=chi2;
      sumchi2 +=chi2*chi2;
      sum++;
    }
  }

  Float_t mdensity = 0.9;
  Float_t meann    = 130;
  Float_t meanchi  = 1;
  Float_t sdensity = 0.1;
  Float_t smeann    = 10;
  Float_t smeanchi  =0.4;
  

  if (sum>20){
    mdensity = sumdens/sum;
    meann    = sumn/sum;
    meanchi  = sumchi/sum;
    //
    sdensity = sumdens2/sum-mdensity*mdensity;
    if (sdensity >= 0)
       sdensity = TMath::Sqrt(sdensity);
    else
       sdensity = 0.1;
    //
    smeann   = sumn2/sum-meann*meann;
    if (smeann >= 0)
      smeann   = TMath::Sqrt(smeann);
    else 
      smeann   = 10;
    //
    smeanchi = sumchi2/sum - meanchi*meanchi;
    if (smeanchi >= 0)
      smeanchi = TMath::Sqrt(smeanchi);
    else
      smeanchi = 0.4;
  }


  //REMOVE  SHORT DELTAS or tracks going out of sensitive volume of TPC
  //
  for (Int_t i=0; i<nseed; i++) {
    AliTPCseed *pt=(AliTPCseed*)arr->UncheckedAt(i);    
    if (!pt) {
      continue;
    }
    if (pt->GetBSigned()) continue;
    if (pt->GetBConstrain()) continue;    
    //if (!(pt->IsActive())) continue;
    /*
    Int_t found,foundable,shared;    
    pt->GetClusterStatistic(0,160,found, foundable,shared);
    if (shared/float(found)>0.3) {
      if (shared/float(found)>0.9 ){
	//MarkSeedFree( arr->RemoveAt(i) );
      }
      continue;
    }
    */
    Bool_t isok =kFALSE;
    if ( (pt->GetNShared()/pt->GetNumberOfClusters()<0.5) &&pt->GetNumberOfClusters()>60)
      isok = kTRUE;
    if ((TMath::Abs(1/pt->GetC())<100.) && (pt->GetNShared()/pt->GetNumberOfClusters()<0.7))
      isok =kTRUE;
    if  (TMath::Abs(pt->GetZ()/pt->GetX())>1.1)
      isok =kTRUE;
    if ( (TMath::Abs(pt->GetSnp()>0.7) && pt->GetD(0,0)>60.))
      isok =kTRUE;
    
    if (isok)     
      for (Int_t j=0; j<160; ++j) {	
	Int_t index=pt->GetClusterIndex2(j);
	if (index<0) continue;
	AliTPCclusterMI *c= pt->GetClusterPointer(j);
	if (!c) continue;
	//if (!(c->IsUsed(10))) c->Use();  
	c->Use(10);  
      }
  }
  
  
  //
  Double_t maxchi  = meanchi+2.*smeanchi;

  for (Int_t i=0; i<nseed; i++) {
    AliTPCseed *pt=(AliTPCseed*)arr->UncheckedAt(i);    
    if (!pt) {
      continue;
    }    
    //if (!(pt->IsActive())) continue;
    if (pt->GetBSigned()) continue;
    Double_t chi     = pt->GetChi2()/pt->GetNumberOfClusters();
    if (chi>maxchi) continue;

    Float_t bfactor=1;
    Float_t dens = pt->GetNumberOfClusters()/Float_t(pt->GetNFoundable());
   
    //sign only tracks with enoug big density at the beginning
    
    if ((pt->GetDensityFirst(40)<0.75) && pt->GetNumberOfClusters()<meann) continue; 
    
    
    Double_t mindens = TMath::Max(double(mdensity-sdensity*fdensity*bfactor),0.65);
    Double_t minn    = TMath::Max(Int_t(meann-fnumber*smeann*bfactor),50);
   
    //    if (pt->fBConstrain) mindens = TMath::Max(mdensity-sdensity*fdensity*bfactor,0.65);
    if ( (pt->GetRemoval()==10) && (pt->GetSnp()>0.8)&&(dens>mindens))
      minn=0;

    if ((dens>mindens && pt->GetNumberOfClusters()>minn) && chi<maxchi ){
      //Int_t noc=pt->GetNumberOfClusters();
      pt->SetBSigned(kTRUE);
      for (Int_t j=0; j<160; ++j) {

	Int_t index=pt->GetClusterIndex2(j);
	if (index<0) continue;
	AliTPCclusterMI *c= pt->GetClusterPointer(j);
	if (!c) continue;
	//	if (!(c->IsUsed(10))) c->Use();  
	c->Use(10);  
      }
    }
  }
  //  gLastCheck = nseed;
  //  arr->Compress();
  if (fDebug>0){
    timer.Print();
  }
}



Int_t AliTPCtracker::RefitInward(AliESDEvent *event)
{
  //
  // back propagation of ESD tracks
  //
  //return 0;
  if (!event) return 0;
  const Int_t kMaxFriendTracks=2000;
  fEvent = event;
  fEventHLT = 0;
  // extract correction object for multiplicity dependence of dEdx
  TObjArray * gainCalibArray = AliTPCcalibDB::Instance()->GetTimeGainSplinesRun(event->GetRunNumber());

  AliTPCTransform *transform = AliTPCcalibDB::Instance()->GetTransform() ;
  if (!transform) {
    AliFatal("Tranformations not in RefitInward");
    return 0;
  }
  transform->SetCurrentRecoParam((AliTPCRecoParam*)AliTPCReconstructor::GetRecoParam());
  const AliTPCRecoParam * recoParam = AliTPCcalibDB::Instance()->GetTransform()->GetCurrentRecoParam();
  Int_t nContribut = event->GetNumberOfTracks();
  TGraphErrors * graphMultDependenceDeDx = 0x0;
  if (recoParam && recoParam->GetUseMultiplicityCorrectionDedx() && gainCalibArray) {
    if (recoParam->GetUseTotCharge()) {
      graphMultDependenceDeDx = (TGraphErrors *) gainCalibArray->FindObject("TGRAPHERRORS_MEANQTOT_MULTIPLICITYDEPENDENCE_BEAM_ALL");
    } else {
      graphMultDependenceDeDx = (TGraphErrors *) gainCalibArray->FindObject("TGRAPHERRORS_MEANQMAX_MULTIPLICITYDEPENDENCE_BEAM_ALL");
    }
  }
  //
  ReadSeeds(event,2);
  fIteration=2;
  //PrepareForProlongation(fSeeds,1);
  PropagateForward2(fSeeds);
  RemoveUsed2(fSeeds,0.4,0.4,20);

  Int_t entriesSeed=fSeeds->GetEntries();
  TObjArray arraySeed(entriesSeed);
  for (Int_t i=0;i<entriesSeed;i++) {
    arraySeed.AddAt(fSeeds->At(i),i);    
  }
  SignShared(&arraySeed);
  //  FindCurling(fSeeds, event,2); // find multi found tracks
  FindSplitted(fSeeds, event,2); // find multi found tracks
  if ((AliTPCReconstructor::StreamLevel()&kStreamFindMultiMC)>0)  FindMultiMC(fSeeds, fEvent,2); // flag: stream MC infomation about the multiple find track (ONLY for MC data)

  Int_t ntracks=0;
  Int_t nseed = fSeeds->GetEntriesFast();
  for (Int_t i=0;i<nseed;i++){
    AliTPCseed * seed = (AliTPCseed*) fSeeds->UncheckedAt(i);
    if (!seed) continue;
    if (seed->GetKinkIndex(0)>0)  UpdateKinkQualityD(seed);  // update quality informations for kinks
    AliESDtrack *esd=event->GetTrack(i);

    if (seed->GetNumberOfClusters()<60 && seed->GetNumberOfClusters()<(esd->GetTPCclusters(0) -5)*0.8){
      AliExternalTrackParam paramIn;
      AliExternalTrackParam paramOut;
      Int_t ncl = seed->RefitTrack(seed,&paramIn,&paramOut);
      if ((AliTPCReconstructor::StreamLevel() & kStreamRecoverIn)>0) {  // flag: stream track information for track  failing in RefitInward function and recovered back
	(*fDebugStreamer)<<"RecoverIn"<< 
	  "seed.="<<seed<<
	  "esd.="<<esd<<
	  "pin.="<<&paramIn<<
	  "pout.="<<&paramOut<<
	  "ncl="<<ncl<<
	  "\n";
      }
      if (ncl>15) {
	seed->Set(paramIn.GetX(),paramIn.GetAlpha(),paramIn.GetParameter(),paramIn.GetCovariance());
	seed->SetNumberOfClusters(ncl);
      }
    }

    seed->PropagateTo(fkParam->GetInnerRadiusLow());
    seed->UpdatePoints();
    AddCovariance(seed);
    MakeESDBitmaps(seed, esd);
    seed->CookdEdx(0.02,0.6);
    CookLabel(seed,0.1); //For comparison only
    //
    if (((AliTPCReconstructor::StreamLevel()&kStreamRefitInward)>0) && seed!=0) {
      TTreeSRedirector &cstream = *fDebugStreamer;
      cstream<<"RefitInward"<<  // flag: stream track information in RefitInward function (after tracking Iteration 2)
	"Esd.="<<esd<<
	"Track.="<<seed<<
	"\n"; 
    }

    if (seed->GetNumberOfClusters()>15){
      esd->UpdateTrackParams(seed,AliESDtrack::kTPCrefit); 
      esd->SetTPCPoints(seed->GetPoints());
      esd->SetTPCPointsF(seed->GetNFoundable());
      Int_t   ndedx = seed->GetNCDEDX(0);
      Float_t sdedx = seed->GetSDEDX(0);
      Float_t dedx  = seed->GetdEdx();
      // apply mutliplicity dependent dEdx correction if available
      if (graphMultDependenceDeDx) {
	Double_t corrGain =  AliTPCcalibDButil::EvalGraphConst(graphMultDependenceDeDx, nContribut);
	dedx += (1 - corrGain)*50.; // MIP is normalized to 50
      }
      esd->SetTPCsignal(dedx, sdedx, ndedx);
      //
      // fill new dEdx information
      //
      Double32_t signal[4]; 
      Double32_t signalMax[4]; 
      Char_t ncl[3]; 
      Char_t nrows[3];
      //
      for(Int_t iarr=0;iarr<3;iarr++) {
	signal[iarr] = seed->GetDEDXregion(iarr+1);
	signalMax[iarr] = seed->GetDEDXregion(iarr+5);
	ncl[iarr] = seed->GetNCDEDX(iarr+1);
	nrows[iarr] = seed->GetNCDEDXInclThres(iarr+1);
      }
      signal[3] = seed->GetDEDXregion(4);
      signalMax[3] = seed->GetDEDXregion(8);
      
      //
      AliTPCdEdxInfo * infoTpcPid = new AliTPCdEdxInfo();
      infoTpcPid->SetTPCSignalRegionInfo(signal, ncl, nrows);
      infoTpcPid->SetTPCSignalsQmax(signalMax);
      esd->SetTPCdEdxInfo(infoTpcPid);
      //
      // add seed to the esd track in Calib level
      //
      Bool_t storeFriend = gRandom->Rndm()<(kMaxFriendTracks)/Float_t(nseed);
      if (AliTPCReconstructor::StreamLevel()>0 &&storeFriend){
	// RS: this is the only place where the seed is created not in the pool, 
	// since it should belong to ESDevent
	AliTPCseed * seedCopy = new AliTPCseed(*seed, kTRUE); 
	esd->AddCalibObject(seedCopy);
      }
      ntracks++;
    }
    else{
      //printf("problem\n");
    }
  }
  //FindKinks(fSeeds,event);
  if ((AliTPCReconstructor::StreamLevel()&kStreamClDump)>0)  DumpClusters(2,fSeeds);  // dump clusters at the end of process (signed with useage flags)
  Info("RefitInward","Number of refitted tracks %d",ntracks);

  AliCosmicTracker::FindCosmic(event, kTRUE);

  FillClusterOccupancyInfo();

  return 0;
}


Int_t AliTPCtracker::PropagateBack(AliESDEvent *event)
{
  //
  // back propagation of ESD tracks
  //
  if (!event) return 0;
  fEvent = event;
  fEventHLT = 0;
  fIteration = 1;
  ReadSeeds(event,1);
  PropagateBack(fSeeds); 
  RemoveUsed2(fSeeds,0.4,0.4,20);
  //FindCurling(fSeeds, fEvent,1);  
  FindSplitted(fSeeds, event,1); // find multi found tracks
  if ((AliTPCReconstructor::StreamLevel()&kStreamFindMultiMC)>0)  FindMultiMC(fSeeds, fEvent,1); // find multi found tracks

  //
  Int_t nseed = fSeeds->GetEntriesFast();
  Int_t ntracks=0;
  for (Int_t i=0;i<nseed;i++){
    AliTPCseed * seed = (AliTPCseed*) fSeeds->UncheckedAt(i);
    if (!seed) continue;
    if (seed->GetKinkIndex(0)<0)  UpdateKinkQualityM(seed);  // update quality informations for kinks
    seed->UpdatePoints();
    AddCovariance(seed);
    AliESDtrack *esd=event->GetTrack(i);
    if (!esd) continue; //never happen
    if (seed->GetNumberOfClusters()<60 && seed->GetNumberOfClusters()<(esd->GetTPCclusters(0) -5)*0.8){
      AliExternalTrackParam paramIn;
      AliExternalTrackParam paramOut;
      Int_t ncl = seed->RefitTrack(seed,&paramIn,&paramOut);
      if ((AliTPCReconstructor::StreamLevel()&kStreamRecoverBack)>0) { // flag: stream track information for track  faling PropagateBack function and recovered back (RefitTrack)
	(*fDebugStreamer)<<"RecoverBack"<<
	  "seed.="<<seed<<
	  "esd.="<<esd<<
	  "pin.="<<&paramIn<<
	  "pout.="<<&paramOut<<
	  "ncl="<<ncl<<
	  "\n";
      }
      if (ncl>15) {
	seed->Set(paramOut.GetX(),paramOut.GetAlpha(),paramOut.GetParameter(),paramOut.GetCovariance());
	seed->SetNumberOfClusters(ncl);
      }
    }
    seed->CookdEdx(0.02,0.6);
    CookLabel(seed,0.1); //For comparison only
    if (seed->GetNumberOfClusters()>15){
      esd->UpdateTrackParams(seed,AliESDtrack::kTPCout);
      esd->SetTPCPoints(seed->GetPoints());
      esd->SetTPCPointsF(seed->GetNFoundable());
      Int_t   ndedx = seed->GetNCDEDX(0);
      Float_t sdedx = seed->GetSDEDX(0);
      Float_t dedx  = seed->GetdEdx();
      esd->SetTPCsignal(dedx, sdedx, ndedx);
      ntracks++;
      Int_t eventnumber = event->GetEventNumberInFile();// patch 28 fev 06
      // This is most likely NOT the event number you'd like to use. It has nothing to do with the 'real' event number      
      if (((AliTPCReconstructor::StreamLevel()&kStreamCPropagateBack)>0) && esd) {
	(*fDebugStreamer)<<"PropagateBack"<<  // flag: stream track information in PropagateBack function (after tracking Iteration 1)
	  "Tr0.="<<seed<<
	  "esd.="<<esd<<
	  "EventNrInFile="<<eventnumber<<
	  "\n";       
      }
    }
  }
  if (AliTPCReconstructor::StreamLevel()&kStreamClDump)  DumpClusters(1,fSeeds); // flag:stream clusters at the end of process (signed with usage flag)
  //FindKinks(fSeeds,event);
  Info("PropagateBack","Number of back propagated tracks %d",ntracks);
  fEvent =0;
  fEventHLT = 0;

  return 0;
}


Int_t AliTPCtracker::PostProcess(AliESDEvent *event)
{
  //
  // Post process events 
  //
  if (!event) return 0;

  //
  // Set TPC event status
  // 

  // event affected by HV dip
  // reset TPC status
  if(IsTPCHVDipEvent(event)) { 
    event->ResetDetectorStatus(AliDAQ::kTPC);
  }
 
  //printf("Status %d \n", event->IsDetectorOn(AliDAQ::kTPC));

  return 0;
}


 void AliTPCtracker::DeleteSeeds()
{
  //
  fSeeds->Clear();
  ResetSeedsPool();
  delete fSeeds;
  fSeeds =0;
}

void AliTPCtracker::ReadSeeds(const AliESDEvent *const event, Int_t direction)
{
  //
  //read seeds from the event
  
  Int_t nentr=event->GetNumberOfTracks();
  if (fDebug>0){
    Info("ReadSeeds", "Number of ESD tracks: %d\n", nentr);
  }
  if (fSeeds) 
    DeleteSeeds();
  if (!fSeeds){   
    fSeeds = new TObjArray(nentr);
  }
  UnsignClusters();
  //  Int_t ntrk=0;  
  for (Int_t i=0; i<nentr; i++) {
    AliESDtrack *esd=event->GetTrack(i);
    ULong_t status=esd->GetStatus();
    if (!(status&AliESDtrack::kTPCin)) continue;
    AliTPCtrack t(*esd);
    t.SetNumberOfClusters(0);
    //    AliTPCseed *seed = new AliTPCseed(t,t.GetAlpha());
    AliTPCseed *seed = new( NextFreeSeed() ) AliTPCseed(t/*,t.GetAlpha()*/);
    seed->SetPoolID(fLastSeedID);
    seed->SetUniqueID(esd->GetID());
    AddCovariance(seed);   //add systematic ucertainty
    for (Int_t ikink=0;ikink<3;ikink++) {
      Int_t index = esd->GetKinkIndex(ikink);
      seed->GetKinkIndexes()[ikink] = index;
      if (index==0) continue;
      index = TMath::Abs(index);
      AliESDkink * kink = fEvent->GetKink(index-1);
      if (kink&&esd->GetKinkIndex(ikink)<0){
	if ((status & AliESDtrack::kTRDrefit) != 0) kink->SetStatus(1,2);
	if ((status & AliESDtrack::kITSout) != 0)   kink->SetStatus(1,0);
      }
      if (kink&&esd->GetKinkIndex(ikink)>0){
	if ((status & AliESDtrack::kTRDrefit) != 0) kink->SetStatus(1,6);
	if ((status & AliESDtrack::kITSout) != 0)   kink->SetStatus(1,4);
      }

    }
    if (((status&AliESDtrack::kITSout)==0)&&(direction==1)) seed->ResetCovariance(10.); 
    //RS    if ( direction ==2 &&(status & AliESDtrack::kTRDrefit) == 0 ) seed->ResetCovariance(10.);
    if ( direction ==2 &&(status & AliESDtrack::kTRDrefit) == 0 ) seed->ResetCovariance(10.);
    //if ( direction ==2 && ((status & AliESDtrack::kTPCout) == 0) ) {
    //  fSeeds->AddAt(0,i);
    //  MarkSeedFree( seed );
    //  continue;    
    //}
    
    //
    //
    // rotate to the local coordinate system
    //   
    fSectors=fInnerSec; fN=fkNIS;    
    Double_t alpha=seed->GetAlpha();
    if (alpha > 2.*TMath::Pi()) alpha -= 2.*TMath::Pi();
    if (alpha < 0.            ) alpha += 2.*TMath::Pi();
    Int_t ns=Int_t(alpha/fSectors->GetAlpha()+0.0001)%fN;
    alpha =ns*fSectors->GetAlpha() + fSectors->GetAlphaShift();
    alpha-=seed->GetAlpha();  
    if (alpha<-TMath::Pi()) alpha += 2*TMath::Pi();
    if (alpha>=TMath::Pi()) alpha -= 2*TMath::Pi();
    if (TMath::Abs(alpha) > 0.001) { // This should not happen normally
      AliWarning(Form("Rotating track over %f",alpha));
      if (!seed->Rotate(alpha)) {
	MarkSeedFree( seed );
	continue;
      }
    }
    seed->SetESD(esd);
    // sign clusters
    if (esd->GetKinkIndex(0)<=0){
      for (Int_t irow=0;irow<160;irow++){
	Int_t index = seed->GetClusterIndex2(irow);    
	if (index >= 0){ 
	  //
	  AliTPCclusterMI * cl = GetClusterMI(index);
	  seed->SetClusterPointer(irow,cl);
	  if (cl){
	    if ((index & 0x8000)==0){
	      cl->Use(10);  // accepted cluster	  
	    }else{
	      cl->Use(6);   // close cluster not accepted
	    }	
	  }else{
	    Info("ReadSeeds","Not found cluster");
	  }
	}
      }
    }
    fSeeds->AddAt(seed,i);
  }
}



//_____________________________________________________________________________
void AliTPCtracker::MakeSeeds3(TObjArray * arr, Int_t sec, Int_t i1, Int_t i2,  Float_t cuts[4],
				 Float_t deltay, Int_t ddsec) {
  //-----------------------------------------------------------------
  // This function creates track seeds.
  // SEEDING WITH VERTEX CONSTRAIN 
  //-----------------------------------------------------------------
  // cuts[0]   - fP4 cut
  // cuts[1]   - tan(phi)  cut
  // cuts[2]   - zvertex cut
  // cuts[3]   - fP3 cut
  Int_t nin0  = 0;
  Int_t nin1  = 0;
  Int_t nin2  = 0;
  Int_t nin   = 0;
  Int_t nout1 = 0;
  Int_t nout2 = 0;

  Double_t x[5], c[15];
  //  Int_t di = i1-i2;
  //
  AliTPCseed * seed = new( NextFreeSeed() ) AliTPCseed();
  seed->SetPoolID(fLastSeedID);
  Double_t alpha=fSectors->GetAlpha(), shift=fSectors->GetAlphaShift();
  Double_t cs=cos(alpha), sn=sin(alpha);
  //
  //  Double_t x1 =fOuterSec->GetX(i1);
  //Double_t xx2=fOuterSec->GetX(i2);
  
  Double_t x1 =GetXrow(i1);
  Double_t xx2=GetXrow(i2);

  Double_t x3=GetX(), y3=GetY(), z3=GetZ();

  Int_t imiddle = (i2+i1)/2;    //middle pad row index
  Double_t xm = GetXrow(imiddle); // radius of middle pad-row
  const AliTPCtrackerRow& krm=GetRow(sec,imiddle); //middle pad -row
  //
  Int_t ns =sec;   

  const AliTPCtrackerRow& kr1=GetRow(ns,i1);
  Double_t ymax  = GetMaxY(i1)-kr1.GetDeadZone()-1.5;  
  Double_t ymaxm = GetMaxY(imiddle)-kr1.GetDeadZone()-1.5;  

  //
  // change cut on curvature if it can't reach this layer
  // maximal curvature set to reach it
  Double_t dvertexmax  = TMath::Sqrt((x1-x3)*(x1-x3)+(ymax+5-y3)*(ymax+5-y3));
  if (dvertexmax*0.5*cuts[0]>0.85){
    cuts[0] = 0.85/(dvertexmax*0.5+1.);
  }
  Double_t r2min = 1/(cuts[0]*cuts[0]);  //minimal square of radius given by cut

  //  Int_t ddsec = 1;
  if (deltay>0) ddsec = 0; 
  // loop over clusters  
  for (Int_t is=0; is < kr1; is++) {
    //
    if (kr1[is]->IsUsed(10)) continue;
    if (kr1[is]->IsDisabled()) {
      continue;
    }

    Double_t y1=kr1[is]->GetY(), z1=kr1[is]->GetZ();    
    //if (TMath::Abs(y1)>ymax) continue;

    if (deltay>0 && TMath::Abs(ymax-TMath::Abs(y1))> deltay ) continue;  // seed only at the edge

    // find possible directions    
    Float_t anglez = (z1-z3)/(x1-x3); 
    Float_t extraz = z1 - anglez*(x1-xx2);  // extrapolated z      
    //
    //
    //find   rotation angles relative to line given by vertex and point 1
    Double_t dvertex2 = (x1-x3)*(x1-x3)+(y1-y3)*(y1-y3);
    Double_t dvertex  = TMath::Sqrt(dvertex2);
    Double_t angle13  = TMath::ATan((y1-y3)/(x1-x3));
    Double_t cs13     = cos(-angle13), sn13 = sin(-angle13);            
    
    //
    // loop over 2 sectors
    Int_t dsec1=-ddsec;
    Int_t dsec2= ddsec;
    if (y1<0)  dsec2= 0;
    if (y1>0)  dsec1= 0;
    
    Double_t dddz1=0;  // direction of delta inclination in z axis
    Double_t dddz2=0;
    if ( (z1-z3)>0)
      dddz1 =1;    
    else
      dddz2 =1;
    //
    for (Int_t dsec = dsec1; dsec<=dsec2;dsec++){
      Int_t sec2 = sec + dsec;
      // 
      //      AliTPCtrackerRow&  kr2  = fOuterSec[(sec2+fkNOS)%fkNOS][i2];
      //AliTPCtrackerRow&  kr2m = fOuterSec[(sec2+fkNOS)%fkNOS][imiddle];
      AliTPCtrackerRow&  kr2  = GetRow((sec2+fkNOS)%fkNOS,i2);
      AliTPCtrackerRow&  kr2m = GetRow((sec2+fkNOS)%fkNOS,imiddle);
      Int_t  index1 = TMath::Max(kr2.Find(extraz-0.6-dddz1*TMath::Abs(z1)*0.05)-1,0);
      Int_t  index2 = TMath::Min(kr2.Find(extraz+0.6+dddz2*TMath::Abs(z1)*0.05)+1,kr2);

      // rotation angles to p1-p3
      Double_t cs13r     = cos(-angle13+dsec*alpha)/dvertex, sn13r = sin(-angle13+dsec*alpha)/dvertex;            
      Double_t x2,   y2,   z2; 
      //
      //      Double_t dymax = maxangle*TMath::Abs(x1-xx2);

      //
      Double_t dxx0 =  (xx2-x3)*cs13r;
      Double_t dyy0 =  (xx2-x3)*sn13r;
      for (Int_t js=index1; js < index2; js++) {
	const AliTPCclusterMI *kcl = kr2[js];
	if (kcl->IsUsed(10)) continue; 	
	if (kcl->IsDisabled()) {
	  continue;
	}
	//
	//calcutate parameters
	//	
	Double_t yy0 =  dyy0 +(kcl->GetY()-y3)*cs13r;
	// stright track
	if (TMath::Abs(yy0)<0.000001) continue;
	Double_t xx0 =  dxx0 -(kcl->GetY()-y3)*sn13r;
	Double_t y0  =  0.5*(xx0*xx0+yy0*yy0-xx0)/yy0;
	Double_t r02 = (0.25+y0*y0)*dvertex2;	
	//curvature (radius) cut
	if (r02<r2min) continue;		
       
	nin0++;	
	//
	Double_t c0  = 1/TMath::Sqrt(r02);
	if (yy0>0) c0*=-1.;	
	       
       
	//Double_t dfi0   = 2.*TMath::ASin(dvertex*c0*0.5);
	//Double_t dfi1   = 2.*TMath::ASin(TMath::Sqrt(yy0*yy0+(1-xx0)*(1-xx0))*dvertex*c0*0.5);
	Double_t dfi0   = 2.*AliTPCFastMath::FastAsin(dvertex*c0*0.5);
	Double_t dfi1   = 2.*AliTPCFastMath::FastAsin(TMath::Sqrt(yy0*yy0+(1-xx0)*(1-xx0))*dvertex*c0*0.5);  
	//
	//
	Double_t z0  =  kcl->GetZ();  
	Double_t zzzz2    = z1-(z1-z3)*dfi1/dfi0;
	if (TMath::Abs(zzzz2-z0)>0.5) continue;       
	nin1++;              
	//	
	Double_t dip    = (z1-z0)*c0/dfi1;        
	Double_t x0 = (0.5*cs13+y0*sn13)*dvertex*c0;
	//
	y2 = kcl->GetY(); 
	if (dsec==0){
	  x2 = xx2; 
	  z2 = kcl->GetZ();	  
	}
	else
	  {
	    // rotation	
	    z2 = kcl->GetZ();  
	    x2= xx2*cs-y2*sn*dsec;
	    y2=+xx2*sn*dsec+y2*cs;
	  }
	
	x[0] = y1;
	x[1] = z1;
	x[2] = x0;
	x[3] = dip;
	x[4] = c0;
	//
	//
	// do we have cluster at the middle ?
	Double_t ym,zm;
	GetProlongation(x1,xm,x,ym,zm);
	UInt_t dummy; 
	AliTPCclusterMI * cm=0;
	if (TMath::Abs(ym)-ymaxm<0){	  
	  cm = krm.FindNearest2(ym,zm,1.0,0.6,dummy);
	  if ((!cm) || (cm->IsUsed(10))) {	  
	    continue;
	  }
	}
	else{	  
	  // rotate y1 to system 0
	  // get state vector in rotated system 
	  Double_t yr1  = (-0.5*sn13+y0*cs13)*dvertex*c0;
	  Double_t xr2  =  x0*cs+yr1*sn*dsec;
	  Double_t xr[5]={kcl->GetY(),kcl->GetZ(), xr2, dip, c0};
	  //
	  GetProlongation(xx2,xm,xr,ym,zm);
	  if (TMath::Abs(ym)-ymaxm<0){
	    cm = kr2m.FindNearest2(ym,zm,1.0,0.6,dummy);
	    if ((!cm) || (cm->IsUsed(10))) {	  
	      continue;
	    }
	  }
	}
       

	// Double_t dym = 0;
	// Double_t dzm = 0;
	// if (cm){
	//   dym = ym - cm->GetY();
	//   dzm = zm - cm->GetZ();
	// }
	nin2++;


	//
	//
        Double_t sy1=kr1[is]->GetSigmaY2()*2., sz1=kr1[is]->GetSigmaZ2()*2.;
        Double_t sy2=kcl->GetSigmaY2()*2.,     sz2=kcl->GetSigmaZ2()*2.;
	//Double_t sy3=400*3./12., sy=0.1, sz=0.1;
	Double_t sy3=25000*x[4]*x[4]+0.1, sy=0.1, sz=0.1;
	//Double_t sy3=25000*x[4]*x[4]*60+0.5, sy=0.1, sz=0.1;

	Double_t f40=(F1(x1,y1+sy,x2,y2,x3,y3)-x[4])/sy;
	Double_t f42=(F1(x1,y1,x2,y2+sy,x3,y3)-x[4])/sy;
	Double_t f43=(F1(x1,y1,x2,y2,x3,y3+sy)-x[4])/sy;
	Double_t f20=(F2(x1,y1+sy,x2,y2,x3,y3)-x[2])/sy;
	Double_t f22=(F2(x1,y1,x2,y2+sy,x3,y3)-x[2])/sy;
	Double_t f23=(F2(x1,y1,x2,y2,x3,y3+sy)-x[2])/sy;
	
	Double_t f30=(F3(x1,y1+sy,x2,y2,z1,z2)-x[3])/sy;
	Double_t f31=(F3(x1,y1,x2,y2,z1+sz,z2)-x[3])/sz;
	Double_t f32=(F3(x1,y1,x2,y2+sy,z1,z2)-x[3])/sy;
	Double_t f34=(F3(x1,y1,x2,y2,z1,z2+sz)-x[3])/sz;
	
        c[0]=sy1;
        c[1]=0.;       c[2]=sz1;
        c[3]=f20*sy1;  c[4]=0.;       c[5]=f20*sy1*f20+f22*sy2*f22+f23*sy3*f23;
        c[6]=f30*sy1;  c[7]=f31*sz1;  c[8]=f30*sy1*f20+f32*sy2*f22;
                       c[9]=f30*sy1*f30+f31*sz1*f31+f32*sy2*f32+f34*sz2*f34;
        c[10]=f40*sy1; c[11]=0.; c[12]=f40*sy1*f20+f42*sy2*f22+f43*sy3*f23;
        c[13]=f30*sy1*f40+f32*sy2*f42;
        c[14]=f40*sy1*f40+f42*sy2*f42+f43*sy3*f43;
	
	//	if (!BuildSeed(kr1[is],kcl,0,x1,x2,x3,x,c)) continue;
	
        UInt_t index=kr1.GetIndex(is);
	if (seed) {MarkSeedFree(seed); seed = 0;}
	AliTPCseed *track = seed = new( NextFreeSeed() ) AliTPCseed(x1, ns*alpha+shift, x, c, index);
	seed->SetPoolID(fLastSeedID);
	track->SetIsSeeding(kTRUE);
	track->SetSeed1(i1);
	track->SetSeed2(i2);
	track->SetSeedType(3);

       
	//if (dsec==0) {
	  FollowProlongation(*track, (i1+i2)/2,1);
	  Int_t foundable,found,shared;
	  track->GetClusterStatistic((i1+i2)/2,i1, found, foundable, shared, kTRUE);
	  if ((found<0.55*foundable)  || shared>0.5*found || (track->GetSigmaY2()+track->GetSigmaZ2())>0.5){
	    MarkSeedFree(seed); seed = 0;
	    continue;
	  }
	  //}
	
	nin++;
	FollowProlongation(*track, i2,1);
	
	
	//Int_t rc = 1;
	track->SetBConstrain(1);
	//	track->fLastPoint = i1+fInnerSec->GetNRows();  // first cluster in track position
	track->SetLastPoint(i1);  // first cluster in track position
	track->SetFirstPoint(track->GetLastPoint());
	
	if (track->GetNumberOfClusters()<(i1-i2)*0.5 || 
	    track->GetNumberOfClusters() < track->GetNFoundable()*0.6 || 
	    track->GetNShared()>0.4*track->GetNumberOfClusters() ) {
	  MarkSeedFree(seed); seed = 0;
	  continue;
	}
	nout1++;
        // Z VERTEX CONDITION
	Double_t zv, bz=GetBz();
        if ( !track->GetZAt(0.,bz,zv) ) continue;
	if (TMath::Abs(zv-z3)>cuts[2]) {
	  FollowProlongation(*track, TMath::Max(i2-20,0));
          if ( !track->GetZAt(0.,bz,zv) ) continue;
	  if (TMath::Abs(zv-z3)>cuts[2]){
	    FollowProlongation(*track, TMath::Max(i2-40,0));
            if ( !track->GetZAt(0.,bz,zv) ) continue;
	    if (TMath::Abs(zv-z3)>cuts[2] &&(track->GetNumberOfClusters() > track->GetNFoundable()*0.7)){
	      // make seed without constrain
	      AliTPCseed * track2 = MakeSeed(track,0.2,0.5,1.);
	      FollowProlongation(*track2, i2,1);
	      track2->SetBConstrain(kFALSE);
	      track2->SetSeedType(1);
	      arr->AddLast(track2); 
	      MarkSeedFree( seed ); seed = 0;
	      continue;		
	    }
	    else{
	      MarkSeedFree( seed ); seed = 0;
	      continue;
	    
	    }
	  }
	}
      
	track->SetSeedType(0);
	arr->AddLast(track); // note, track is seed, don't free the seed
	seed = new( NextFreeSeed() ) AliTPCseed; 	
	seed->SetPoolID(fLastSeedID);
	nout2++;
	// don't consider other combinations
	if (track->GetNumberOfClusters() > track->GetNFoundable()*0.8)
	  break;
      }
    }
  }
  if (fDebug>3){
    Info("MakeSeeds3","\nSeeding statistic:\t%d\t%d\t%d\t%d\t%d\t%d",nin0,nin1,nin2,nin,nout1,nout2);
  }
  if (seed) MarkSeedFree( seed );
}


void AliTPCtracker::MakeSeeds5(TObjArray * arr, Int_t sec, Int_t i1, Int_t i2,  Float_t cuts[4],
				 Float_t deltay) {
  


  //-----------------------------------------------------------------
  // This function creates track seeds.
  //-----------------------------------------------------------------
  // cuts[0]   - fP4 cut
  // cuts[1]   - tan(phi)  cut
  // cuts[2]   - zvertex cut
  // cuts[3]   - fP3 cut


  Int_t nin0  = 0;
  Int_t nin1  = 0;
  Int_t nin2  = 0;
  Int_t nin   = 0;
  Int_t nout1 = 0;
  Int_t nout2 = 0;
  Int_t nout3 =0;
  Double_t x[5], c[15];
  //
  // make temporary seed
  AliTPCseed * seed = new( NextFreeSeed() ) AliTPCseed;
  seed->SetPoolID(fLastSeedID);
  Double_t alpha=fOuterSec->GetAlpha(), shift=fOuterSec->GetAlphaShift();
  //  Double_t cs=cos(alpha), sn=sin(alpha);
  //
  //

  // first 3 padrows
  Double_t x1 = GetXrow(i1-1);
  const    AliTPCtrackerRow& kr1=GetRow(sec,i1-1);
  Double_t y1max  = GetMaxY(i1-1)-kr1.GetDeadZone()-1.5;  
  //
  Double_t x1p = GetXrow(i1);
  const    AliTPCtrackerRow& kr1p=GetRow(sec,i1);
  //
  Double_t x1m = GetXrow(i1-2);
  const    AliTPCtrackerRow& kr1m=GetRow(sec,i1-2);

  //
  //last 3 padrow for seeding
  AliTPCtrackerRow&  kr3  = GetRow((sec+fkNOS)%fkNOS,i1-7);
  Double_t    x3   =  GetXrow(i1-7);
  //  Double_t    y3max= GetMaxY(i1-7)-kr3.fDeadZone-1.5;  
  //
  AliTPCtrackerRow&  kr3p  = GetRow((sec+fkNOS)%fkNOS,i1-6);
  Double_t    x3p   = GetXrow(i1-6);
  //
  AliTPCtrackerRow&  kr3m  = GetRow((sec+fkNOS)%fkNOS,i1-8);
  Double_t    x3m   = GetXrow(i1-8);

  //
  //
  // middle padrow
  Int_t im = i1-4;                           //middle pad row index
  Double_t xm         = GetXrow(im);         // radius of middle pad-row
  const AliTPCtrackerRow& krm=GetRow(sec,im);   //middle pad -row
  //  Double_t ymmax = GetMaxY(im)-kr1.fDeadZone-1.5;  
  //
  //
  Double_t deltax  = x1-x3;
  Double_t dymax   = deltax*cuts[1];
  Double_t dzmax   = deltax*cuts[3];
  //
  // loop over clusters  
  for (Int_t is=0; is < kr1; is++) {
    //
    if (kr1[is]->IsUsed(10)) continue;	
    if (kr1[is]->IsDisabled()) {
      continue;
    }

    Double_t y1=kr1[is]->GetY(), z1=kr1[is]->GetZ();    
    //
    if (deltay>0 && TMath::Abs(y1max-TMath::Abs(y1))> deltay ) continue;  // seed only at the edge    
    // 
    Int_t  index1 = TMath::Max(kr3.Find(z1-dzmax)-1,0);
    Int_t  index2 = TMath::Min(kr3.Find(z1+dzmax)+1,kr3);
    //    
    Double_t y3,   z3;
    //
    //
    UInt_t index;
    for (Int_t js=index1; js < index2; js++) {
      const AliTPCclusterMI *kcl = kr3[js];
      if (kcl->IsDisabled()) {
	continue;
      }

      if (kcl->IsUsed(10)) continue;
      y3 = kcl->GetY(); 
      // apply angular cuts
      if (TMath::Abs(y1-y3)>dymax) continue;
      //x3 = x3; 
      z3 = kcl->GetZ();	
      if (TMath::Abs(z1-z3)>dzmax) continue;
      //
      Double_t angley = (y1-y3)/(x1-x3);
      Double_t anglez = (z1-z3)/(x1-x3);
      //
      Double_t erry = TMath::Abs(angley)*(x1-x1m)*0.5+0.5;
      Double_t errz = TMath::Abs(anglez)*(x1-x1m)*0.5+0.5;
      //
      Double_t yyym = angley*(xm-x1)+y1;
      Double_t zzzm = anglez*(xm-x1)+z1;

      const AliTPCclusterMI *kcm = krm.FindNearest2(yyym,zzzm,erry,errz,index);
      if (!kcm) continue;
      if (kcm->IsUsed(10)) continue;
      if (kcm->IsDisabled()) {
	continue;
      }

      erry = TMath::Abs(angley)*(x1-x1m)*0.4+0.5;
      errz = TMath::Abs(anglez)*(x1-x1m)*0.4+0.5;
      //
      //
      //
      Int_t used  =0;
      Int_t found =0;
      //
      // look around first
      const AliTPCclusterMI *kc1m = kr1m.FindNearest2(angley*(x1m-x1)+y1,
						      anglez*(x1m-x1)+z1,
						      erry,errz,index);
      //
      if (kc1m){
	found++;
	if (kc1m->IsUsed(10)) used++;
      }
      const AliTPCclusterMI *kc1p = kr1p.FindNearest2(angley*(x1p-x1)+y1,
						      anglez*(x1p-x1)+z1,
						      erry,errz,index);
      //
      if (kc1p){
	found++;
	if (kc1p->IsUsed(10)) used++;
      }
      if (used>1)  continue;
      if (found<1) continue; 

      //
      // look around last
      const AliTPCclusterMI *kc3m = kr3m.FindNearest2(angley*(x3m-x3)+y3,
						      anglez*(x3m-x3)+z3,
						      erry,errz,index);
      //
      if (kc3m){
	found++;
	if (kc3m->IsUsed(10)) used++;
      }
      else 
	continue;
      const AliTPCclusterMI *kc3p = kr3p.FindNearest2(angley*(x3p-x3)+y3,
						      anglez*(x3p-x3)+z3,
						      erry,errz,index);
      //
      if (kc3p){
	found++;
	if (kc3p->IsUsed(10)) used++;
      }
      else 
	continue;
      if (used>1)  continue;
      if (found<3) continue;       
      //
      Double_t x2,y2,z2;
      x2 = xm;
      y2 = kcm->GetY();
      z2 = kcm->GetZ();
      //
                  	
      x[0]=y1;
      x[1]=z1;
      x[4]=F1(x1,y1,x2,y2,x3,y3);
      //if (TMath::Abs(x[4]) >= cuts[0]) continue;
      nin0++;
      //
      x[2]=F2(x1,y1,x2,y2,x3,y3);
      nin1++;
      //
      x[3]=F3n(x1,y1,x2,y2,z1,z2,x[4]);
      //if (TMath::Abs(x[3]) > cuts[3]) continue;
      nin2++;
      //
      //
      Double_t sy1=0.1,  sz1=0.1;
      Double_t sy2=0.1,  sz2=0.1;
      Double_t sy3=0.1,  sy=0.1, sz=0.1;
      
      Double_t f40=(F1(x1,y1+sy,x2,y2,x3,y3)-x[4])/sy;
      Double_t f42=(F1(x1,y1,x2,y2+sy,x3,y3)-x[4])/sy;
      Double_t f43=(F1(x1,y1,x2,y2,x3,y3+sy)-x[4])/sy;
      Double_t f20=(F2(x1,y1+sy,x2,y2,x3,y3)-x[2])/sy;
      Double_t f22=(F2(x1,y1,x2,y2+sy,x3,y3)-x[2])/sy;
      Double_t f23=(F2(x1,y1,x2,y2,x3,y3+sy)-x[2])/sy;
      
      Double_t f30=(F3(x1,y1+sy,x2,y2,z1,z2)-x[3])/sy;
      Double_t f31=(F3(x1,y1,x2,y2,z1+sz,z2)-x[3])/sz;
      Double_t f32=(F3(x1,y1,x2,y2+sy,z1,z2)-x[3])/sy;
      Double_t f34=(F3(x1,y1,x2,y2,z1,z2+sz)-x[3])/sz;
      
      c[0]=sy1;
      c[1]=0.;       c[2]=sz1; 
      c[3]=f20*sy1;  c[4]=0.;       c[5]=f20*sy1*f20+f22*sy2*f22+f23*sy3*f23;
      c[6]=f30*sy1;  c[7]=f31*sz1;  c[8]=f30*sy1*f20+f32*sy2*f22;
      c[9]=f30*sy1*f30+f31*sz1*f31+f32*sy2*f32+f34*sz2*f34;
      c[10]=f40*sy1; c[11]=0.; c[12]=f40*sy1*f20+f42*sy2*f22+f43*sy3*f23;
      c[13]=f30*sy1*f40+f32*sy2*f42;
      c[14]=f40*sy1*f40+f42*sy2*f42+f43*sy3*f43;
      
      //	if (!BuildSeed(kr1[is],kcl,0,x1,x2,x3,x,c)) continue;
      
      index=kr1.GetIndex(is);
      if (seed) {MarkSeedFree( seed ); seed = 0;}
      AliTPCseed *track = seed = new( NextFreeSeed() ) AliTPCseed(x1, sec*alpha+shift, x, c, index);
      seed->SetPoolID(fLastSeedID);
      
      track->SetIsSeeding(kTRUE);

      nin++;      
      FollowProlongation(*track, i1-7,1);
      if (track->GetNumberOfClusters() < track->GetNFoundable()*0.75 || 
	  track->GetNShared()>0.6*track->GetNumberOfClusters() || ( track->GetSigmaY2()+ track->GetSigmaZ2())>0.6){
	MarkSeedFree( seed ); seed = 0;
	continue;
      }
      nout1++;
      nout2++;	
      //Int_t rc = 1;
      FollowProlongation(*track, i2,1);
      track->SetBConstrain(0);
      track->SetLastPoint(i1+fInnerSec->GetNRows());  // first cluster in track position
      track->SetFirstPoint(track->GetLastPoint());
      
      if (track->GetNumberOfClusters()<(i1-i2)*0.5 || 
	  track->GetNumberOfClusters()<track->GetNFoundable()*0.7 || 
	  track->GetNShared()>2. || track->GetChi2()/track->GetNumberOfClusters()>6 || ( track->GetSigmaY2()+ track->GetSigmaZ2())>0.5 ) {
	MarkSeedFree( seed ); seed = 0;
	continue;
      }
   
      {
	FollowProlongation(*track, TMath::Max(i2-10,0),1);
	AliTPCseed * track2 = MakeSeed(track,0.2,0.5,0.9);
	FollowProlongation(*track2, i2,1);
	track2->SetBConstrain(kFALSE);
	track2->SetSeedType(4);
	arr->AddLast(track2);
	MarkSeedFree( seed ); seed = 0;
      }
      
   
      //arr->AddLast(track); 
      //seed = new AliTPCseed; 	
      nout3++;
    }
  }
  
  if (fDebug>3){
    Info("MakeSeeds5","\nSeeding statiistic:\t%d\t%d\t%d\t%d\t%d\t%d\t%d",nin0,nin1,nin2,nin,nout1,nout2,nout3);
  }
  if (seed) MarkSeedFree(seed);
}


//_____________________________________________________________________________
void AliTPCtracker::MakeSeeds2(TObjArray * arr, Int_t sec, Int_t i1, Int_t i2, Float_t */*cuts[4]*/,
				 Float_t deltay, Bool_t /*bconstrain*/) {
  //-----------------------------------------------------------------
  // This function creates track seeds - without vertex constraint
  //-----------------------------------------------------------------
  // cuts[0]   - fP4 cut        - not applied
  // cuts[1]   - tan(phi)  cut
  // cuts[2]   - zvertex cut    - not applied 
  // cuts[3]   - fP3 cut
  Int_t nin0=0;
  Int_t nin1=0;
  Int_t nin2=0;
  Int_t nin3=0;
  //  Int_t nin4=0;
  //Int_t nin5=0;

  

  Double_t alpha=fOuterSec->GetAlpha(), shift=fOuterSec->GetAlphaShift();
  //  Double_t cs=cos(alpha), sn=sin(alpha);
  Int_t row0 = (i1+i2)/2;
  Int_t drow = (i1-i2)/2;
  const AliTPCtrackerRow& kr0=fSectors[sec][row0];
  AliTPCtrackerRow * kr=0;

  AliTPCpolyTrack polytrack;
  Int_t nclusters=fSectors[sec][row0];
  AliTPCseed * seed = new( NextFreeSeed() ) AliTPCseed;
  seed->SetPoolID(fLastSeedID);

  Int_t sumused=0;
  Int_t cused=0;
  Int_t cnused=0;
  for (Int_t is=0; is < nclusters; is++) {  //LOOP over clusters
    Int_t nfound =0;
    Int_t nfoundable =0;
    for (Int_t iter =1; iter<2; iter++){   //iterations
      const AliTPCtrackerRow& krm=fSectors[sec][row0-iter];
      const AliTPCtrackerRow& krp=fSectors[sec][row0+iter];      
      const AliTPCclusterMI * cl= kr0[is];
      if (cl->IsDisabled()) {
	continue;
      }

      if (cl->IsUsed(10)) {
	cused++;
      }
      else{
	cnused++;
      }
      Double_t x = kr0.GetX();
      // Initialization of the polytrack
      nfound =0;
      nfoundable =0;
      polytrack.Reset();
      //
      Double_t y0= cl->GetY();
      Double_t z0= cl->GetZ();
      Float_t erry = 0;
      Float_t errz = 0;
      
      Double_t ymax = fSectors->GetMaxY(row0)-kr0.GetDeadZone()-1.5;
      if (deltay>0 && TMath::Abs(ymax-TMath::Abs(y0))> deltay ) continue;  // seed only at the edge
      
      erry = (0.5)*cl->GetSigmaY2()/TMath::Sqrt(cl->GetQ())*6;	    
      errz = (0.5)*cl->GetSigmaZ2()/TMath::Sqrt(cl->GetQ())*6;      
      polytrack.AddPoint(x,y0,z0,erry, errz);

      sumused=0;
      if (cl->IsUsed(10)) sumused++;


      Float_t roady = (5*TMath::Sqrt(cl->GetSigmaY2()+0.2)+1.)*iter;
      Float_t roadz = (5*TMath::Sqrt(cl->GetSigmaZ2()+0.2)+1.)*iter;
      //
      x = krm.GetX();
      AliTPCclusterMI * cl1 = krm.FindNearest(y0,z0,roady,roadz);
      if (cl1 && TMath::Abs(ymax-TMath::Abs(y0))) {
	erry = (0.5)*cl1->GetSigmaY2()/TMath::Sqrt(cl1->GetQ())*3;	    
	errz = (0.5)*cl1->GetSigmaZ2()/TMath::Sqrt(cl1->GetQ())*3;
	if (cl1->IsUsed(10))  sumused++;
	polytrack.AddPoint(x,cl1->GetY(),cl1->GetZ(),erry,errz);
      }
      //
      x = krp.GetX();
      AliTPCclusterMI * cl2 = krp.FindNearest(y0,z0,roady,roadz);
      if (cl2) {
	erry = (0.5)*cl2->GetSigmaY2()/TMath::Sqrt(cl2->GetQ())*3;	    
	errz = (0.5)*cl2->GetSigmaZ2()/TMath::Sqrt(cl2->GetQ())*3;
	if (cl2->IsUsed(10)) sumused++;	 
	polytrack.AddPoint(x,cl2->GetY(),cl2->GetZ(),erry,errz);
      }
      //
      if (sumused>0) continue;
      nin0++;
      polytrack.UpdateParameters();
      // follow polytrack
      roadz = 1.2;
      roady = 1.2;
      //
      Double_t yn,zn;
      nfoundable = polytrack.GetN();
      nfound     = nfoundable; 
      //
      for (Int_t ddrow = iter+1; ddrow<drow;ddrow++){
	Float_t maxdist = 0.8*(1.+3./(ddrow));
	for (Int_t delta = -1;delta<=1;delta+=2){
	  Int_t row = row0+ddrow*delta;
	  kr = &(fSectors[sec][row]);
	  Double_t xn = kr->GetX();
	  Double_t ymax1 = fSectors->GetMaxY(row)-kr->GetDeadZone()-1.5;
	  polytrack.GetFitPoint(xn,yn,zn);
	  if (TMath::Abs(yn)>ymax1) continue;
	  nfoundable++;
	  AliTPCclusterMI * cln = kr->FindNearest(yn,zn,roady,roadz);
	  if (cln) {
	    Float_t dist =  TMath::Sqrt(  (yn-cln->GetY())*(yn-cln->GetY())+(zn-cln->GetZ())*(zn-cln->GetZ()));
	    if (dist<maxdist){
	      /*
	      erry = (dist+0.3)*cln->GetSigmaY2()/TMath::Sqrt(cln->GetQ())*(1.+1./(ddrow));	    
	      errz = (dist+0.3)*cln->GetSigmaZ2()/TMath::Sqrt(cln->GetQ())*(1.+1./(ddrow));
	      if (cln->IsUsed(10)) {
		//	printf("used\n");
		sumused++;
		erry*=2;
		errz*=2;
	      }
	      */
	      erry=0.1;
	      errz=0.1;
	      polytrack.AddPoint(xn,cln->GetY(),cln->GetZ(),erry, errz);
	      nfound++;
	    }
	  }
	}
	if ( (sumused>3) || (sumused>0.5*nfound) || (nfound<0.6*nfoundable))  break;     
	polytrack.UpdateParameters();
      }           
    }
    if ( (sumused>3) || (sumused>0.5*nfound))  {
      //printf("sumused   %d\n",sumused);
      continue;
    }
    nin1++;
    Double_t dy,dz;
    polytrack.GetFitDerivation(kr0.GetX(),dy,dz);
    AliTPCpolyTrack track2;
    
    polytrack.Refit(track2,0.5+TMath::Abs(dy)*0.3,0.4+TMath::Abs(dz)*0.3);
    if (track2.GetN()<0.5*nfoundable) continue;
    nin2++;

    if ((nfound>0.6*nfoundable) &&( nfoundable>0.4*(i1-i2))) {
      //
      // test seed with and without constrain
      for (Int_t constrain=0; constrain<=0;constrain++){
	// add polytrack candidate

	Double_t x[5], c[15];
	Double_t x1,x2,x3,y1,y2,y3,z1,z2,z3;
	track2.GetBoundaries(x3,x1);	
	x2 = (x1+x3)/2.;
	track2.GetFitPoint(x1,y1,z1);
	track2.GetFitPoint(x2,y2,z2);
	track2.GetFitPoint(x3,y3,z3);
	//
	//is track pointing to the vertex ?
	Double_t x0,y0,z0;
	x0=0;
	polytrack.GetFitPoint(x0,y0,z0);

	if (constrain) {
	  x2 = x3;
	  y2 = y3;
	  z2 = z3;
	  
	  x3 = 0;
	  y3 = 0;
	  z3 = 0;
	}
	x[0]=y1;
	x[1]=z1;
	x[4]=F1(x1,y1,x2,y2,x3,y3);
		
	//	if (TMath::Abs(x[4]) >= cuts[0]) continue;  //
	x[2]=F2(x1,y1,x2,y2,x3,y3);
	
	//if (TMath::Abs(x[4]*x1-x[2]) >= cuts[1]) continue;
	//x[3]=F3(x1,y1,x2,y2,z1,z2);
	x[3]=F3n(x1,y1,x3,y3,z1,z3,x[4]);
	//if (TMath::Abs(x[3]) > cuts[3]) continue;

	
	Double_t sy =0.1, sz =0.1;
	Double_t sy1=0.02, sz1=0.02;
	Double_t sy2=0.02, sz2=0.02;
	Double_t sy3=0.02;

	if (constrain){
	  sy3=25000*x[4]*x[4]+0.1, sy=0.1, sz=0.1;
	}
	
	Double_t f40=(F1(x1,y1+sy,x2,y2,x3,y3)-x[4])/sy;
	Double_t f42=(F1(x1,y1,x2,y2+sy,x3,y3)-x[4])/sy;
	Double_t f43=(F1(x1,y1,x2,y2,x3,y3+sy)-x[4])/sy;
	Double_t f20=(F2(x1,y1+sy,x2,y2,x3,y3)-x[2])/sy;
	Double_t f22=(F2(x1,y1,x2,y2+sy,x3,y3)-x[2])/sy;
	Double_t f23=(F2(x1,y1,x2,y2,x3,y3+sy)-x[2])/sy;

	Double_t f30=(F3(x1,y1+sy,x3,y3,z1,z3)-x[3])/sy;
	Double_t f31=(F3(x1,y1,x3,y3,z1+sz,z3)-x[3])/sz;
	Double_t f32=(F3(x1,y1,x3,y3+sy,z1,z3)-x[3])/sy;
	Double_t f34=(F3(x1,y1,x3,y3,z1,z3+sz)-x[3])/sz;

	
	c[0]=sy1;
	c[1]=0.;       c[2]=sz1;
	c[3]=f20*sy1;  c[4]=0.;       c[5]=f20*sy1*f20+f22*sy2*f22+f23*sy3*f23;
	c[6]=f30*sy1;  c[7]=f31*sz1;  c[8]=f30*sy1*f20+f32*sy2*f22;
	c[9]=f30*sy1*f30+f31*sz1*f31+f32*sy2*f32+f34*sz2*f34;
	c[10]=f40*sy1; c[11]=0.; c[12]=f40*sy1*f20+f42*sy2*f22+f43*sy3*f23;
	c[13]=f30*sy1*f40+f32*sy2*f42;
	c[14]=f40*sy1*f40+f42*sy2*f42+f43*sy3*f43;
	
	//Int_t row1 = fSectors->GetRowNumber(x1);
	Int_t row1 = GetRowNumber(x1);

	UInt_t index=0;
	//kr0.GetIndex(is);
	if (seed) {MarkSeedFree( seed ); seed = 0;}
	AliTPCseed *track = seed = new( NextFreeSeed() ) AliTPCseed(x1,sec*alpha+shift,x,c,index);
	seed->SetPoolID(fLastSeedID);
	track->SetIsSeeding(kTRUE);
	Int_t rc=FollowProlongation(*track, i2);	
	if (constrain) track->SetBConstrain(1);
	else
	  track->SetBConstrain(0);
	track->SetLastPoint(row1+fInnerSec->GetNRows());  // first cluster in track position
	track->SetFirstPoint(track->GetLastPoint());

	if (rc==0 || track->GetNumberOfClusters()<(i1-i2)*0.5 || 
	    track->GetNumberOfClusters() < track->GetNFoundable()*0.6 || 
	    track->GetNShared()>0.4*track->GetNumberOfClusters()) {
	  MarkSeedFree( seed ); seed = 0;
	}
	else {
	  arr->AddLast(track); // track IS seed, don't free seed
	  seed = new( NextFreeSeed() ) AliTPCseed;
	  seed->SetPoolID(fLastSeedID);
	}
	nin3++;
      }
    }  // if accepted seed
  }
  if (fDebug>3){
    Info("MakeSeeds2","\nSeeding statiistic:\t%d\t%d\t%d\t%d",nin0,nin1,nin2,nin3);
  }
  if (seed) MarkSeedFree( seed );
}


AliTPCseed *AliTPCtracker::MakeSeed(AliTPCseed *const track, Float_t r0, Float_t r1, Float_t r2)
{
  //
  //
  //reseed using track points
  Int_t p0 = int(r0*track->GetNumberOfClusters());     // point 0 
  Int_t p1 = int(r1*track->GetNumberOfClusters());
  Int_t p2 = int(r2*track->GetNumberOfClusters());   // last point
  Int_t pp2=0;
  Double_t  x0[3],x1[3],x2[3];
  for (Int_t i=0;i<3;i++){
    x0[i]=-1;
    x1[i]=-1;
    x2[i]=-1;
  }

  // find track position at given ratio of the length
  Int_t  sec0=0, sec1=0, sec2=0;
  Int_t index=-1;
  Int_t clindex;
  for (Int_t i=0;i<160;i++){
    if (track->GetClusterPointer(i)){
      index++;
      AliTPCTrackerPoint   *trpoint =track->GetTrackPoint(i);
      if ( (index<p0) || x0[0]<0 ){
	if (trpoint->GetX()>1){
	  clindex = track->GetClusterIndex2(i);
	  if (clindex >= 0){	
	    x0[0] = trpoint->GetX();
	    x0[1] = trpoint->GetY();
	    x0[2] = trpoint->GetZ();
	    sec0  = ((clindex&0xff000000)>>24)%18;
	  }
	}
      }

      if ( (index<p1) &&(trpoint->GetX()>1)){
	clindex = track->GetClusterIndex2(i);
	if (clindex >= 0){
	  x1[0] = trpoint->GetX();
	  x1[1] = trpoint->GetY();
	  x1[2] = trpoint->GetZ();
	  sec1  = ((clindex&0xff000000)>>24)%18;
	}
      }
      if ( (index<p2) &&(trpoint->GetX()>1)){
	clindex = track->GetClusterIndex2(i);
	if (clindex >= 0){
	  x2[0] = trpoint->GetX();
	  x2[1] = trpoint->GetY();
	  x2[2] = trpoint->GetZ(); 
	  sec2  = ((clindex&0xff000000)>>24)%18;
	  pp2 = i;
	}
      }
    }
  }
  
  Double_t alpha, cs,sn, xx2,yy2;
  //
  alpha = (sec1-sec2)*fSectors->GetAlpha();
  cs = TMath::Cos(alpha);
  sn = TMath::Sin(alpha); 
  xx2= x1[0]*cs-x1[1]*sn;
  yy2= x1[0]*sn+x1[1]*cs;
  x1[0] = xx2;
  x1[1] = yy2;
  //
  alpha = (sec0-sec2)*fSectors->GetAlpha();
  cs = TMath::Cos(alpha);
  sn = TMath::Sin(alpha); 
  xx2= x0[0]*cs-x0[1]*sn;
  yy2= x0[0]*sn+x0[1]*cs;
  x0[0] = xx2;
  x0[1] = yy2;
  //
  //
  //
  Double_t x[5],c[15];
  //
  x[0]=x2[1];
  x[1]=x2[2];
  x[4]=F1(x2[0],x2[1],x1[0],x1[1],x0[0],x0[1]);
  //  if (x[4]>1) return 0;
  x[2]=F2(x2[0],x2[1],x1[0],x1[1],x0[0],x0[1]);
  x[3]=F3n(x2[0],x2[1],x0[0],x0[1],x2[2],x0[2],x[4]);
  //if (TMath::Abs(x[3]) > 2.2)  return 0;
  //if (TMath::Abs(x[2]) > 1.99) return 0;
  //  
  Double_t sy =0.1,  sz =0.1;
  //
  Double_t sy1=0.02+track->GetSigmaY2(), sz1=0.02+track->GetSigmaZ2();
  Double_t sy2=0.01+track->GetSigmaY2(), sz2=0.01+track->GetSigmaZ2();
  Double_t sy3=0.01+track->GetSigmaY2();
  //
  Double_t f40=(F1(x2[0],x2[1]+sy,x1[0],x1[1],x0[0],x0[1])-x[4])/sy;
  Double_t f42=(F1(x2[0],x2[1],x1[0],x1[1]+sy,x0[0],x0[1])-x[4])/sy;
  Double_t f43=(F1(x2[0],x2[1],x1[0],x1[1],x0[0],x0[1]+sy)-x[4])/sy;
  Double_t f20=(F2(x2[0],x2[1]+sy,x1[0],x1[1],x0[0],x0[1])-x[2])/sy;
  Double_t f22=(F2(x2[0],x2[1],x1[0],x1[1]+sy,x0[0],x0[1])-x[2])/sy;
  Double_t f23=(F2(x2[0],x2[1],x1[0],x1[1],x0[0],x0[1]+sy)-x[2])/sy;
  //
  Double_t f30=(F3(x2[0],x2[1]+sy,x0[0],x0[1],x2[2],x0[2])-x[3])/sy;
  Double_t f31=(F3(x2[0],x2[1],x0[0],x0[1],x2[2]+sz,x0[2])-x[3])/sz;
  Double_t f32=(F3(x2[0],x2[1],x0[0],x0[1]+sy,x2[2],x0[2])-x[3])/sy;
  Double_t f34=(F3(x2[0],x2[1],x0[0],x0[1],x2[2],x0[2]+sz)-x[3])/sz;
  
  
  c[0]=sy1;
  c[1]=0.;       c[2]=sz1;
  c[3]=f20*sy1;  c[4]=0.;       c[5]=f20*sy1*f20+f22*sy2*f22+f23*sy3*f23;
  c[6]=f30*sy1;  c[7]=f31*sz1;  c[8]=f30*sy1*f20+f32*sy2*f22;
  c[9]=f30*sy1*f30+f31*sz1*f31+f32*sy2*f32+f34*sz2*f34;
  c[10]=f40*sy1; c[11]=0.; c[12]=f40*sy1*f20+f42*sy2*f22+f43*sy3*f23;
  c[13]=f30*sy1*f40+f32*sy2*f42;
  c[14]=f40*sy1*f40+f42*sy2*f42+f43*sy3*f43;
  
  //  Int_t row1 = fSectors->GetRowNumber(x2[0]);
  AliTPCseed *seed = new( NextFreeSeed() )  AliTPCseed(x2[0], sec2*fSectors->GetAlpha()+fSectors->GetAlphaShift(), x, c, 0);
  seed->SetPoolID(fLastSeedID);
  //  Double_t y0,z0,y1,z1, y2,z2;
  //seed->GetProlongation(x0[0],y0,z0);
  // seed->GetProlongation(x1[0],y1,z1);
  //seed->GetProlongation(x2[0],y2,z2);
  //  seed =0;
  seed->SetLastPoint(pp2);
  seed->SetFirstPoint(pp2);
  

  return seed;
}


AliTPCseed *AliTPCtracker::ReSeed(const AliTPCseed *track, Float_t r0, Float_t r1, Float_t r2)
{
  //
  //
  //reseed using founded clusters 
  //
  // Find the number of clusters
  Int_t nclusters = 0;
  for (Int_t irow=0;irow<160;irow++){
    if (track->GetClusterIndex(irow)>0) nclusters++;
  }
  //
  Int_t ipos[3];
  ipos[0] = TMath::Max(int(r0*nclusters),0);             // point 0 cluster
  ipos[1] = TMath::Min(int(r1*nclusters),nclusters-1);   // 
  ipos[2] = TMath::Min(int(r2*nclusters),nclusters-1);   // last point
  //
  //
  Double_t  xyz[3][3]={{0}};
  Int_t     row[3]={0},sec[3]={0,0,0};
  //
  // find track row position at given ratio of the length
  Int_t index=-1;
  for (Int_t irow=0;irow<160;irow++){    
    if (track->GetClusterIndex2(irow)<0) continue;
    index++;
    for (Int_t ipoint=0;ipoint<3;ipoint++){
      if (index<=ipos[ipoint]) row[ipoint] = irow;
    }        
  }
  //
  //Get cluster and sector position
  for (Int_t ipoint=0;ipoint<3;ipoint++){
    Int_t clindex = track->GetClusterIndex2(row[ipoint]);
    AliTPCclusterMI * cl = GetClusterMI(clindex);
    if (cl==0) {
      //Error("Bug\n");
      //      AliTPCclusterMI * cl = GetClusterMI(clindex);
      return 0;
    }
    sec[ipoint]     = ((clindex&0xff000000)>>24)%18;
    xyz[ipoint][0]  = GetXrow(row[ipoint]);
    xyz[ipoint][1]  = cl->GetY();
    xyz[ipoint][2]  = cl->GetZ();
  }
  //
  //
  // Calculate seed state vector and covariance matrix

  Double_t alpha, cs,sn, xx2,yy2;
  //
  alpha = (sec[1]-sec[2])*fSectors->GetAlpha();
  cs = TMath::Cos(alpha);
  sn = TMath::Sin(alpha); 
  xx2= xyz[1][0]*cs-xyz[1][1]*sn;
  yy2= xyz[1][0]*sn+xyz[1][1]*cs;
  xyz[1][0] = xx2;
  xyz[1][1] = yy2;
  //
  alpha = (sec[0]-sec[2])*fSectors->GetAlpha();
  cs = TMath::Cos(alpha);
  sn = TMath::Sin(alpha); 
  xx2= xyz[0][0]*cs-xyz[0][1]*sn;
  yy2= xyz[0][0]*sn+xyz[0][1]*cs;
  xyz[0][0] = xx2;
  xyz[0][1] = yy2;
  //
  //
  //
  Double_t x[5],c[15];
  //
  x[0]=xyz[2][1];
  x[1]=xyz[2][2];
  x[4]=F1(xyz[2][0],xyz[2][1],xyz[1][0],xyz[1][1],xyz[0][0],xyz[0][1]);
  x[2]=F2(xyz[2][0],xyz[2][1],xyz[1][0],xyz[1][1],xyz[0][0],xyz[0][1]);
  x[3]=F3n(xyz[2][0],xyz[2][1],xyz[0][0],xyz[0][1],xyz[2][2],xyz[0][2],x[4]);
  //  
  Double_t sy =0.1,  sz =0.1;
  //
  Double_t sy1=0.2, sz1=0.2;
  Double_t sy2=0.2, sz2=0.2;
  Double_t sy3=0.2;
  //
  Double_t f40=(F1(xyz[2][0],xyz[2][1]+sy,xyz[1][0],xyz[1][1],xyz[0][0],xyz[0][1])-x[4])/sy;
  Double_t f42=(F1(xyz[2][0],xyz[2][1],xyz[1][0],xyz[1][1]+sy,xyz[0][0],xyz[0][1])-x[4])/sy;
  Double_t f43=(F1(xyz[2][0],xyz[2][1],xyz[1][0],xyz[1][1],xyz[0][0],xyz[0][1]+sy)-x[4])/sy;
  Double_t f20=(F2(xyz[2][0],xyz[2][1]+sy,xyz[1][0],xyz[1][1],xyz[0][0],xyz[0][1])-x[2])/sy;
  Double_t f22=(F2(xyz[2][0],xyz[2][1],xyz[1][0],xyz[1][1]+sy,xyz[0][0],xyz[0][1])-x[2])/sy;
  Double_t f23=(F2(xyz[2][0],xyz[2][1],xyz[1][0],xyz[1][1],xyz[0][0],xyz[0][1]+sy)-x[2])/sy;
  //
  Double_t f30=(F3(xyz[2][0],xyz[2][1]+sy,xyz[0][0],xyz[0][1],xyz[2][2],xyz[0][2])-x[3])/sy;
  Double_t f31=(F3(xyz[2][0],xyz[2][1],xyz[0][0],xyz[0][1],xyz[2][2]+sz,xyz[0][2])-x[3])/sz;
  Double_t f32=(F3(xyz[2][0],xyz[2][1],xyz[0][0],xyz[0][1]+sy,xyz[2][2],xyz[0][2])-x[3])/sy;
  Double_t f34=(F3(xyz[2][0],xyz[2][1],xyz[0][0],xyz[0][1],xyz[2][2],xyz[0][2]+sz)-x[3])/sz;
  
  
  c[0]=sy1;
  c[1]=0.;       c[2]=sz1;
  c[3]=f20*sy1;  c[4]=0.;       c[5]=f20*sy1*f20+f22*sy2*f22+f23*sy3*f23;
  c[6]=f30*sy1;  c[7]=f31*sz1;  c[8]=f30*sy1*f20+f32*sy2*f22;
  c[9]=f30*sy1*f30+f31*sz1*f31+f32*sy2*f32+f34*sz2*f34;
  c[10]=f40*sy1; c[11]=0.; c[12]=f40*sy1*f20+f42*sy2*f22+f43*sy3*f23;
  c[13]=f30*sy1*f40+f32*sy2*f42;
  c[14]=f40*sy1*f40+f42*sy2*f42+f43*sy3*f43;
  
  //  Int_t row1 = fSectors->GetRowNumber(xyz[2][0]);
  AliTPCseed *seed=new( NextFreeSeed() ) AliTPCseed(xyz[2][0], sec[2]*fSectors->GetAlpha()+fSectors->GetAlphaShift(), x, c, 0);
  seed->SetPoolID(fLastSeedID);
  seed->SetLastPoint(row[2]);
  seed->SetFirstPoint(row[2]);  
  return seed;
}


AliTPCseed *AliTPCtracker::ReSeed(AliTPCseed *track,Int_t r0, Bool_t forward)
{
  //
  //
  //reseed using founded clusters 
  //
  Double_t  xyz[3][3];
  Int_t     row[3]={0,0,0};
  Int_t     sec[3]={0,0,0};
  //
  // forward direction
  if (forward){
    for (Int_t irow=r0;irow<160;irow++){
      if (track->GetClusterIndex(irow)>0){
	row[0] = irow;
	break;
      }
    }
    for (Int_t irow=160;irow>r0;irow--){
      if (track->GetClusterIndex(irow)>0){
	row[2] = irow;
	break;
      }
    }
    for (Int_t irow=row[2]-15;irow>row[0];irow--){
      if (track->GetClusterIndex(irow)>0){
	row[1] = irow;
	break;
      }
    }
    //
  }
  if (!forward){
    for (Int_t irow=0;irow<r0;irow++){
      if (track->GetClusterIndex(irow)>0){
	row[0] = irow;
	break;
      }
    }
    for (Int_t irow=r0;irow>0;irow--){
      if (track->GetClusterIndex(irow)>0){
	row[2] = irow;
	break;
      }
    }    
    for (Int_t irow=row[2]-15;irow>row[0];irow--){
      if (track->GetClusterIndex(irow)>0){
	row[1] = irow;
	break;
      }
    } 
  }
  //
  if ((row[2]-row[0])<20) return 0;
  if (row[1]==0) return 0;
  //
  //
  //Get cluster and sector position
  for (Int_t ipoint=0;ipoint<3;ipoint++){
    Int_t clindex = track->GetClusterIndex2(row[ipoint]);
    AliTPCclusterMI * cl = GetClusterMI(clindex);
    if (cl==0) {
      //Error("Bug\n");
      //      AliTPCclusterMI * cl = GetClusterMI(clindex);
      return 0;
    }
    sec[ipoint]     = ((clindex&0xff000000)>>24)%18;
    xyz[ipoint][0]  = GetXrow(row[ipoint]);
    AliTPCTrackerPoint * point = track->GetTrackPoint(row[ipoint]);    
    if (point&&ipoint<2){
      //
       xyz[ipoint][1]  = point->GetY();
       xyz[ipoint][2]  = point->GetZ();
    }
    else{
      xyz[ipoint][1]  = cl->GetY();
      xyz[ipoint][2]  = cl->GetZ();
    }
  }
  //
  //
  //
  //
  // Calculate seed state vector and covariance matrix

  Double_t alpha, cs,sn, xx2,yy2;
  //
  alpha = (sec[1]-sec[2])*fSectors->GetAlpha();
  cs = TMath::Cos(alpha);
  sn = TMath::Sin(alpha); 
  xx2= xyz[1][0]*cs-xyz[1][1]*sn;
  yy2= xyz[1][0]*sn+xyz[1][1]*cs;
  xyz[1][0] = xx2;
  xyz[1][1] = yy2;
  //
  alpha = (sec[0]-sec[2])*fSectors->GetAlpha();
  cs = TMath::Cos(alpha);
  sn = TMath::Sin(alpha); 
  xx2= xyz[0][0]*cs-xyz[0][1]*sn;
  yy2= xyz[0][0]*sn+xyz[0][1]*cs;
  xyz[0][0] = xx2;
  xyz[0][1] = yy2;
  //
  //
  //
  Double_t x[5],c[15];
  //
  x[0]=xyz[2][1];
  x[1]=xyz[2][2];
  x[4]=F1(xyz[2][0],xyz[2][1],xyz[1][0],xyz[1][1],xyz[0][0],xyz[0][1]);
  x[2]=F2(xyz[2][0],xyz[2][1],xyz[1][0],xyz[1][1],xyz[0][0],xyz[0][1]);
  x[3]=F3n(xyz[2][0],xyz[2][1],xyz[0][0],xyz[0][1],xyz[2][2],xyz[0][2],x[4]);
  //  
  Double_t sy =0.1,  sz =0.1;
  //
  Double_t sy1=0.2, sz1=0.2;
  Double_t sy2=0.2, sz2=0.2;
  Double_t sy3=0.2;
  //
  Double_t f40=(F1(xyz[2][0],xyz[2][1]+sy,xyz[1][0],xyz[1][1],xyz[0][0],xyz[0][1])-x[4])/sy;
  Double_t f42=(F1(xyz[2][0],xyz[2][1],xyz[1][0],xyz[1][1]+sy,xyz[0][0],xyz[0][1])-x[4])/sy;
  Double_t f43=(F1(xyz[2][0],xyz[2][1],xyz[1][0],xyz[1][1],xyz[0][0],xyz[0][1]+sy)-x[4])/sy;
  Double_t f20=(F2(xyz[2][0],xyz[2][1]+sy,xyz[1][0],xyz[1][1],xyz[0][0],xyz[0][1])-x[2])/sy;
  Double_t f22=(F2(xyz[2][0],xyz[2][1],xyz[1][0],xyz[1][1]+sy,xyz[0][0],xyz[0][1])-x[2])/sy;
  Double_t f23=(F2(xyz[2][0],xyz[2][1],xyz[1][0],xyz[1][1],xyz[0][0],xyz[0][1]+sy)-x[2])/sy;
  //
  Double_t f30=(F3(xyz[2][0],xyz[2][1]+sy,xyz[0][0],xyz[0][1],xyz[2][2],xyz[0][2])-x[3])/sy;
  Double_t f31=(F3(xyz[2][0],xyz[2][1],xyz[0][0],xyz[0][1],xyz[2][2]+sz,xyz[0][2])-x[3])/sz;
  Double_t f32=(F3(xyz[2][0],xyz[2][1],xyz[0][0],xyz[0][1]+sy,xyz[2][2],xyz[0][2])-x[3])/sy;
  Double_t f34=(F3(xyz[2][0],xyz[2][1],xyz[0][0],xyz[0][1],xyz[2][2],xyz[0][2]+sz)-x[3])/sz;
  
  
  c[0]=sy1;
  c[1]=0.;       c[2]=sz1;
  c[3]=f20*sy1;  c[4]=0.;       c[5]=f20*sy1*f20+f22*sy2*f22+f23*sy3*f23;
  c[6]=f30*sy1;  c[7]=f31*sz1;  c[8]=f30*sy1*f20+f32*sy2*f22;
  c[9]=f30*sy1*f30+f31*sz1*f31+f32*sy2*f32+f34*sz2*f34;
  c[10]=f40*sy1; c[11]=0.; c[12]=f40*sy1*f20+f42*sy2*f22+f43*sy3*f23;
  c[13]=f30*sy1*f40+f32*sy2*f42;
  c[14]=f40*sy1*f40+f42*sy2*f42+f43*sy3*f43;
  
  //  Int_t row1 = fSectors->GetRowNumber(xyz[2][0]);
  AliTPCseed *seed=new( NextFreeSeed() )  AliTPCseed(xyz[2][0], sec[2]*fSectors->GetAlpha()+fSectors->GetAlphaShift(), x, c, 0);
  seed->SetPoolID(fLastSeedID);
  seed->SetLastPoint(row[2]);
  seed->SetFirstPoint(row[2]);  
  for (Int_t i=row[0];i<row[2];i++){
    seed->SetClusterIndex(i, track->GetClusterIndex(i));
  }

  return seed;
}



void  AliTPCtracker::FindMultiMC(const TObjArray * array, AliESDEvent */*esd*/, Int_t iter)
{
  //
  //  find multi tracks - THIS FUNCTION IS ONLY FOR DEBUG PURPOSES
  //                      USES MC LABELS
  //  Use AliTPCReconstructor::StreamLevel()& kStreamFindMultiMC if you want to tune parameters - cuts
  //
  //  Two reasons to have multiple find tracks
  //  1. Curling tracks can be find more than once
  //  2. Splitted tracks 
  //     a.) Multiple seeding to increase tracking efficiency - (~ 100% reached)        
  //     b.) Edge effect on the sector boundaries
  //
  //
  //  Algorithm done in 2 phases - because of CPU consumption
  //  it is n^2 algorithm - for lead-lead 20000x20000 combination are investigated                           
  //
  //  Algorihm for curling tracks sign:
  //    1 phase -makes a very rough fast cuts to minimize combinatorics
  //                 a.) opposite sign
  //                 b.) one of the tracks - not pointing to the primary vertex - 
  //                 c.) delta tan(theta)
  //                 d.) delta phi
  //    2 phase - calculates DCA between tracks  - time consument

  //
  //    fast cuts 
  //
  //    General cuts    - for splitted tracks and for curling tracks
  //
  const Float_t kMaxdPhi      = 0.2;  // maximal distance in phi
  //
  //    Curling tracks cuts
  //
  //
  //
  //
  Int_t nentries = array->GetEntriesFast();  
  AliHelix *helixes      = new AliHelix[nentries];
  Float_t  *xm           = new Float_t[nentries];
  Float_t  *dz0           = new Float_t[nentries];
  Float_t  *dz1           = new Float_t[nentries];
  //
  //
  TStopwatch timer;
  timer.Start();
  //
  // Find track COG in x direction - point with best defined parameters
  //
  for (Int_t i=0;i<nentries;i++){
    AliTPCseed* track = (AliTPCseed*)array->At(i);    
    if (!track) continue;
    track->SetCircular(0);
    new (&helixes[i]) AliHelix(*track);
    Int_t ncl=0;
    xm[i]=0;
    Float_t dz[2];
    track->GetDZ(GetX(),GetY(),GetZ(),GetBz(),dz);
    dz0[i]=dz[0];
    dz1[i]=dz[1];
    for (Int_t icl=0; icl<160; icl++){
      AliTPCclusterMI * cl =  track->GetClusterPointer(icl);
      if (cl) {
	xm[i]+=cl->GetX();
	ncl++;
      }
    }
    if (ncl>0) xm[i]/=Float_t(ncl);
  }  
  //
  for (Int_t i0=0;i0<nentries;i0++){
    AliTPCseed * track0 = (AliTPCseed*)array->At(i0);
    if (!track0) continue;    
    Float_t xc0 = helixes[i0].GetHelix(6);
    Float_t yc0 = helixes[i0].GetHelix(7);
    Float_t r0  = helixes[i0].GetHelix(8);
    Float_t rc0 = TMath::Sqrt(xc0*xc0+yc0*yc0);
    Float_t fi0 = TMath::ATan2(yc0,xc0);
    
    for (Int_t i1=i0+1;i1<nentries;i1++){
      AliTPCseed * track1 = (AliTPCseed*)array->At(i1);
      if (!track1) continue;      
      Int_t lab0=track0->GetLabel();
      Int_t lab1=track1->GetLabel();
      if (TMath::Abs(lab0)!=TMath::Abs(lab1)) continue;
      //
      Float_t xc1 = helixes[i1].GetHelix(6);
      Float_t yc1 = helixes[i1].GetHelix(7);
      Float_t r1  = helixes[i1].GetHelix(8);
      Float_t rc1 = TMath::Sqrt(xc1*xc1+yc1*yc1);
      Float_t fi1 = TMath::ATan2(yc1,xc1);
      //
      Float_t dfi = fi0-fi1;
      //
      //
      if (dfi>1.5*TMath::Pi())  dfi-=TMath::Pi();  // take care about edge effect 
      if (dfi<-1.5*TMath::Pi()) dfi+=TMath::Pi();  // 
      if (TMath::Abs(dfi)>kMaxdPhi&&helixes[i0].GetHelix(4)*helixes[i1].GetHelix(4)<0){
	//
	// if short tracks with undefined sign 
	fi1 =  -TMath::ATan2(yc1,-xc1);
	dfi = fi0-fi1;
      }
      Float_t dtheta = TMath::Abs(track0->GetTgl()-track1->GetTgl())<TMath::Abs(track0->GetTgl()+track1->GetTgl())? track0->GetTgl()-track1->GetTgl():track0->GetTgl()+track1->GetTgl();
      
      //
      // debug stream to tune "fast cuts" 
      //
      Double_t dist[3];   // distance at X 
      Double_t mdist[3]={0,0,0};  // mean distance X+-40cm
      track0->GetDistance(track1,0.5*(xm[i0]+xm[i1])-40.,dist,AliTracker::GetBz());
      for (Int_t i=0;i<3;i++) mdist[i]+=TMath::Abs(dist[i]);
      track0->GetDistance(track1,0.5*(xm[i0]+xm[i1])+40.,dist,AliTracker::GetBz());
      for (Int_t i=0;i<3;i++) mdist[i]+=TMath::Abs(dist[i]);
      track0->GetDistance(track1,0.5*(xm[i0]+xm[i1]),dist,AliTracker::GetBz());
      for (Int_t i=0;i<3;i++) mdist[i]+=TMath::Abs(dist[i]);
      for (Int_t i=0;i<3;i++) mdist[i]*=0.33333;
      
      Float_t sum =0;
      Float_t sums=0;
      for (Int_t icl=0; icl<160; icl++){
	AliTPCclusterMI * cl0 =  track0->GetClusterPointer(icl);
	AliTPCclusterMI * cl1 =  track1->GetClusterPointer(icl);
	if (cl0&&cl1) {
	  sum++;
	  if (cl0==cl1) sums++;
	}
      }
      //
      if ((AliTPCReconstructor::StreamLevel()&kStreamFindMultiMC)>0) {  // flag: stream MC infomation about the multiple find track (ONLY for MC data)
      TTreeSRedirector &cstream = *fDebugStreamer;
      cstream<<"Multi"<<
	"iter="<<iter<<
	"lab0="<<lab0<<
	"lab1="<<lab1<<   
	"Tr0.="<<track0<<       // seed0
	"Tr1.="<<track1<<       // seed1
	"h0.="<<&helixes[i0]<<
	"h1.="<<&helixes[i1]<<
	//
	"sum="<<sum<<           //the sum of rows with cl in both
	"sums="<<sums<<         //the sum of shared clusters
	"xm0="<<xm[i0]<<        // the center of track
	"xm1="<<xm[i1]<<        // the x center of track
	// General cut variables                   
	"dfi="<<dfi<<           // distance in fi angle
	"dtheta="<<dtheta<<     // distance int theta angle
	//
	"dz00="<<dz0[i0]<<
	"dz01="<<dz0[i1]<<
	"dz10="<<dz1[i1]<<
	"dz11="<<dz1[i1]<<
	"dist0="<<dist[0]<<     //distance x
	"dist1="<<dist[1]<<     //distance y
	"dist2="<<dist[2]<<     //distance z
	"mdist0="<<mdist[0]<<   //distance x
	"mdist1="<<mdist[1]<<   //distance y
	"mdist2="<<mdist[2]<<   //distance z
	//
	"r0="<<r0<<
	"rc0="<<rc0<<
	"fi0="<<fi0<<
	"fi1="<<fi1<<
	"r1="<<r1<<
	"rc1="<<rc1<<
	"\n";
	}
    }
  }    
  delete [] helixes;
  delete [] xm;
  delete [] dz0;
  delete [] dz1;
  if (AliTPCReconstructor::StreamLevel()>0) {
    AliInfo("Time for curling tracks removal DEBUGGING MC");
    timer.Print();
  }
}



void  AliTPCtracker::FindSplitted(TObjArray * array, AliESDEvent */*esd*/, Int_t /*iter*/){
  //
  // Find Splitted tracks and remove the one with worst quality  
  // Corresponding debug streamer to tune selections - "Splitted2"
  // Algorithm:
  // 0. Sort tracks according quality
  // 1. Propagate the tracks to the reference radius
  // 2. Double_t loop to select close tracks (only to speed up process)
  // 3. Calculate cluster overlap ratio - and remove the track if bigger than a threshold
  // 4. Delete temporary parameters
  // 
  const Double_t xref=GetXrow(63);  // reference radius -IROC/OROC boundary
  //    rough cuts
  const Double_t kCutP1=10;       // delta Z cut 10 cm 
  const Double_t kCutP2=0.15;     // delta snp(fi) cut 0.15 
  const Double_t kCutP3=0.15;     // delta tgl(theta) cut 0.15
  const Double_t kCutAlpha=0.15;  // delta alpha cut
  Int_t firstpoint = 0;
  Int_t lastpoint = 160;
  //
  Int_t nentries = array->GetEntriesFast();  
  AliExternalTrackParam *params      = new AliExternalTrackParam[nentries];
  //
  //
  TStopwatch timer;
  timer.Start();
  //
  //0.  Sort tracks according quality
  //1.  Propagate the ext. param to reference radius
  Int_t nseed = array->GetEntriesFast();  
  if (nseed<=0) return;
  Float_t * quality = new Float_t[nseed];
  Int_t   * indexes = new Int_t[nseed];
  for (Int_t i=0; i<nseed; i++) {
    AliTPCseed *pt=(AliTPCseed*)array->UncheckedAt(i);    
    if (!pt){
      quality[i]=-1;
      continue;
    }
    pt->UpdatePoints();    //select first last max dens points
    Float_t * points = pt->GetPoints();
    if (points[3]<0.8) quality[i] =-1;
    quality[i] = (points[2]-points[0])+pt->GetNumberOfClusters();
    //prefer high momenta tracks if overlaps
    quality[i] *= TMath::Sqrt(TMath::Abs(pt->Pt())+0.5);
    params[i]=(*pt);
    AliTracker::PropagateTrackToBxByBz(&(params[i]),xref,pt->GetMass(),5.,kTRUE);
    AliTracker::PropagateTrackToBxByBz(&(params[i]),xref,pt->GetMass(),1.,kTRUE);
  }
  TMath::Sort(nseed,quality,indexes);
  //
  // 3. Loop over pair of tracks
  //
  for (Int_t i0=0; i0<nseed; i0++) {
    Int_t index0=indexes[i0];
    if (!(array->UncheckedAt(index0))) continue;
    AliTPCseed *s1 = (AliTPCseed*)array->UncheckedAt(index0);  
    if (!s1->IsActive()) continue;
    AliExternalTrackParam &par0=params[index0];
    for (Int_t i1=i0+1; i1<nseed; i1++) {
      Int_t index1=indexes[i1];
      if (!(array->UncheckedAt(index1))) continue;
      AliTPCseed *s2 = (AliTPCseed*)array->UncheckedAt(index1);  
      if (!s2->IsActive()) continue;
      if (s2->GetKinkIndexes()[0]!=0)
	if (s2->GetKinkIndexes()[0] == -s1->GetKinkIndexes()[0]) continue;
      AliExternalTrackParam &par1=params[index1];
      if (TMath::Abs(par0.GetParameter()[3]-par1.GetParameter()[3])>kCutP3) continue;
      if (TMath::Abs(par0.GetParameter()[1]-par1.GetParameter()[1])>kCutP1) continue;
      if (TMath::Abs(par0.GetParameter()[2]-par1.GetParameter()[2])>kCutP2) continue;
      Double_t dAlpha= TMath::Abs(par0.GetAlpha()-par1.GetAlpha());
      if (dAlpha>TMath::Pi()) dAlpha-=TMath::Pi();
      if (TMath::Abs(dAlpha)>kCutAlpha) continue;
      //
      Int_t sumShared=0;
      Int_t nall0=0;
      Int_t nall1=0;
      Int_t firstShared=lastpoint, lastShared=firstpoint;
      Int_t firstRow=lastpoint, lastRow=firstpoint;
      //
      for (Int_t i=firstpoint;i<lastpoint;i++){
	if (s1->GetClusterIndex2(i)>0) nall0++;
	if (s2->GetClusterIndex2(i)>0) nall1++;
	if  (s1->GetClusterIndex2(i)>0 && s2->GetClusterIndex2(i)>0) {
	  if (i<firstRow) firstRow=i;
	  if (i>lastRow)  lastRow=i;
	}
	if ( (s1->GetClusterIndex2(i))==(s2->GetClusterIndex2(i)) && s1->GetClusterIndex2(i)>0) {
	  if (i<firstShared) firstShared=i;
	  if (i>lastShared)  lastShared=i;
	  sumShared++;
	}
      }
      Double_t ratio0 = Float_t(sumShared)/Float_t(TMath::Min(nall0+1,nall1+1));
      Double_t ratio1 = Float_t(sumShared)/Float_t(TMath::Max(nall0+1,nall1+1));
      
      if ((AliTPCReconstructor::StreamLevel()&kStreamSplitted2)>0){ // flag:stream information about discarded TPC tracks pair algorithm 
	TTreeSRedirector &cstream = *fDebugStreamer;
	Int_t n0=s1->GetNumberOfClusters();
	Int_t n1=s2->GetNumberOfClusters();
	Int_t n0F=s1->GetNFoundable();
	Int_t n1F=s2->GetNFoundable();
	Int_t lab0=s1->GetLabel();
	Int_t lab1=s2->GetLabel();

	cstream<<"Splitted2"<<    // flag:stream information about discarded TPC tracks pair algorithm 
	  "iter="<<fIteration<<
	  "lab0="<<lab0<<        // MC label if exist
	  "lab1="<<lab1<<        // MC label if exist
	  "index0="<<index0<<
	  "index1="<<index1<<
 	  "ratio0="<<ratio0<<      // shared ratio
 	  "ratio1="<<ratio1<<      // shared ratio
	  "p0.="<<&par0<<        // track parameters
	  "p1.="<<&par1<<
	  "s0.="<<s1<<           // full seed
	  "s1.="<<s2<<
	  "n0="<<n0<<     // number of clusters track 0
	  "n1="<<n1<<     // number of clusters track 1
	  "nall0="<<nall0<<     // number of clusters track 0
	  "nall1="<<nall1<<     // number of clusters track 1
	  "n0F="<<n0F<<   // number of findable
	  "n1F="<<n1F<<   // number of findable
	  "shared="<<sumShared<<    // number of shared clusters
	  "firstS="<<firstShared<<  // first and the last shared row
	  "lastS="<<lastShared<<
	  "firstRow="<<firstRow<<   // first and the last row with cluster
	  "lastRow="<<lastRow<<     //
	  "\n";
      }
      //
      // remove track with lower quality
      //
      if (ratio0>AliTPCReconstructor::GetRecoParam()->GetCutSharedClusters(0) ||
	  ratio1>AliTPCReconstructor::GetRecoParam()->GetCutSharedClusters(1)){
	//
	//
	//
	MarkSeedFree( array->RemoveAt(index1) );
      }
    }
  }
  //
  // 4. Delete temporary array
  //
  delete [] params; 
  delete [] quality;
  delete [] indexes;

}



void  AliTPCtracker::FindCurling(const TObjArray * array, AliESDEvent */*esd*/, Int_t iter)
{
  //
  //  find Curling tracks
  //  Use AliTPCReconstructor::StreamLevel()&kStreamFindCurling if you want to tune parameters - cuts
  //
  //
  //  Algorithm done in 2 phases - because of CPU consumption
  //  it is n^2 algorithm - for lead-lead 20000x20000 combination are investigated                           
  //  see detal in MC part what can be used to cut
  //
  //    
  //
  const Float_t kMaxC         = 400;  // maximal curvature to of the track
  const Float_t kMaxdTheta    = 0.15;  // maximal distance in theta
  const Float_t kMaxdPhi      = 0.15;  // maximal distance in phi
  const Float_t kPtRatio      = 0.3; // ratio between pt
  const Float_t kMinDCAR      = 2.;   // distance to the primary vertex in r - see cpipe cut      

  //
  //    Curling tracks cuts
  //
  //
  const Float_t kMaxDeltaRMax = 40;   // distance in outer radius
  const Float_t kMaxDeltaRMin = 5.;   // distance in lower radius - see cpipe cut
  const Float_t kMinAngle     = 2.9;  // angle between tracks
  const Float_t kMaxDist      = 5;    // biggest distance 
  //
  // The cuts can be tuned using the "MC information stored in Multi tree ==> see FindMultiMC
  /* 
     Fast cuts:
     TCut csign("csign","Tr0.fP[4]*Tr1.fP[4]<0"); //opposite sign
     TCut cmax("cmax","abs(Tr0.GetC())>1/400");
     TCut cda("cda","sqrt(dtheta^2+dfi^2)<0.15");
     TCut ccratio("ccratio","abs((Tr0.fP[4]+Tr1.fP[4])/(abs(Tr0.fP[4])+abs(Tr1.fP[4])))<0.3");
     TCut cpipe("cpipe", "min(abs(r0-rc0),abs(r1-rc1))>5");    
     //
     TCut cdrmax("cdrmax","abs(abs(rc0+r0)-abs(rc1+r1))<40")
     TCut cdrmin("cdrmin","abs(abs(rc0+r0)-abs(rc1+r1))<10")
     //
     Multi->Draw("dfi","iter==0"+csign+cmax+cda+ccratio); ~94% of curling tracks fulfill 
     Multi->Draw("min(abs(r0-rc0),abs(r1-rc1))","iter==0&&abs(lab1)==abs(lab0)"+csign+cmax+cda+ccratio+cpipe+cdrmin+cdrmax); //80%
     //
     Curling2->Draw("dfi","iter==0&&abs(lab0)==abs(lab1)"+csign+cmax+cdtheta+cdfi+ccratio)

  */
  //  
  //
  //
  Int_t nentries = array->GetEntriesFast();  
  AliHelix *helixes      = new AliHelix[nentries];
  for (Int_t i=0;i<nentries;i++){
    AliTPCseed* track = (AliTPCseed*)array->At(i);    
    if (!track) continue;
    track->SetCircular(0);
    new (&helixes[i]) AliHelix(*track);
  }
  //
  //
  TStopwatch timer;
  timer.Start();
  Double_t phase[2][2]={{0,0},{0,0}},radius[2]={0,0};

  //
  // Find tracks
  //
  //
  for (Int_t i0=0;i0<nentries;i0++){
    AliTPCseed * track0 = (AliTPCseed*)array->At(i0);
    if (!track0) continue;    
    if (TMath::Abs(track0->GetC())<1/kMaxC) continue;
    Float_t xc0 = helixes[i0].GetHelix(6);
    Float_t yc0 = helixes[i0].GetHelix(7);
    Float_t r0  = helixes[i0].GetHelix(8);
    Float_t rc0 = TMath::Sqrt(xc0*xc0+yc0*yc0);
    Float_t fi0 = TMath::ATan2(yc0,xc0);
    
    for (Int_t i1=i0+1;i1<nentries;i1++){
      AliTPCseed * track1 = (AliTPCseed*)array->At(i1);
      if (!track1) continue;      
      if (TMath::Abs(track1->GetC())<1/kMaxC) continue;    
      Float_t xc1 = helixes[i1].GetHelix(6);
      Float_t yc1 = helixes[i1].GetHelix(7);
      Float_t r1  = helixes[i1].GetHelix(8);
      Float_t rc1 = TMath::Sqrt(xc1*xc1+yc1*yc1);
      Float_t fi1 = TMath::ATan2(yc1,xc1);
      //
      Float_t dfi = fi0-fi1;
      //
      //
      if (dfi>1.5*TMath::Pi())  dfi-=TMath::Pi();  // take care about edge effect 
      if (dfi<-1.5*TMath::Pi()) dfi+=TMath::Pi();  // 
      Float_t dtheta = TMath::Abs(track0->GetTgl()-track1->GetTgl())<TMath::Abs(track0->GetTgl()+track1->GetTgl())? track0->GetTgl()-track1->GetTgl():track0->GetTgl()+track1->GetTgl();
      //
      //
      // FIRST fast cuts
      if (track0->GetBConstrain()&&track1->GetBConstrain())  continue;  // not constrained
      if (track1->GetSigned1Pt()*track0->GetSigned1Pt()>0)   continue; // not the same sign
      if ( TMath::Abs(track1->GetTgl()+track0->GetTgl())>kMaxdTheta) continue; //distance in the Theta
      if ( TMath::Abs(dfi)>kMaxdPhi) continue;  //distance in phi
      if ( TMath::Sqrt(dfi*dfi+dtheta*dtheta)>kMaxdPhi) continue; //common angular offset
      //
      Float_t pt0 = track0->GetSignedPt();
      Float_t pt1 = track1->GetSignedPt();
      if ((TMath::Abs(pt0+pt1)/(TMath::Abs(pt0)+TMath::Abs(pt1)))>kPtRatio) continue;      
      if ((iter==1) && TMath::Abs(TMath::Abs(rc0+r0)-TMath::Abs(rc1+r1))>kMaxDeltaRMax) continue;
      if ((iter!=1) &&TMath::Abs(TMath::Abs(rc0-r0)-TMath::Abs(rc1-r1))>kMaxDeltaRMin) continue;
      if (TMath::Min(TMath::Abs(rc0-r0),TMath::Abs(rc1-r1))<kMinDCAR) continue;
      //
      //
      // Now find closest approach
      //
      //
      //
      Int_t npoints = helixes[i0].GetRPHIintersections(helixes[i1], phase, radius,10);
      if (npoints==0) continue;
      helixes[i0].GetClosestPhases(helixes[i1], phase);
      //
      Double_t xyz0[3];
      Double_t xyz1[3];
      Double_t hangles[3];
      helixes[i0].Evaluate(phase[0][0],xyz0);
      helixes[i1].Evaluate(phase[0][1],xyz1);

      helixes[i0].GetAngle(phase[0][0],helixes[i1],phase[0][1],hangles);
      Double_t deltah[2],deltabest;
      if (TMath::Abs(hangles[2])<kMinAngle) continue;

      if (npoints>0){
	Int_t ibest=0;
	helixes[i0].ParabolicDCA(helixes[i1],phase[0][0],phase[0][1],radius[0],deltah[0],2);
	if (npoints==2){
	  helixes[i0].ParabolicDCA(helixes[i1],phase[1][0],phase[1][1],radius[1],deltah[1],2);
	  if (deltah[1]<deltah[0]) ibest=1;
	}
	deltabest  = TMath::Sqrt(deltah[ibest]);
	helixes[i0].Evaluate(phase[ibest][0],xyz0);
	helixes[i1].Evaluate(phase[ibest][1],xyz1);
	helixes[i0].GetAngle(phase[ibest][0],helixes[i1],phase[ibest][1],hangles);
	Double_t radiusbest = TMath::Sqrt(radius[ibest]);
	//
	if (deltabest>kMaxDist) continue;
	//	if (mindcar+mindcaz<40 && (TMath::Abs(hangles[2])<kMinAngle ||deltabest>3)) continue;
	Bool_t sign =kFALSE;
	if (hangles[2]>kMinAngle) sign =kTRUE;
	//
	if (sign){
	  //	  circular[i0] = kTRUE;
	  //      circular[i1] = kTRUE;
	  if (track0->OneOverPt()<track1->OneOverPt()){
	    track0->SetCircular(track0->GetCircular()+1);
	    track1->SetCircular(track1->GetCircular()+2);
	  }
	  else{
	    track1->SetCircular(track1->GetCircular()+1);
	    track0->SetCircular(track0->GetCircular()+2);
	  }
	}		
	if ((AliTPCReconstructor::StreamLevel()&kStreamFindCurling)>0){  // flag: stream track infroamtion if the FindCurling tracks method	  
	  //
	  //debug stream to tune "fine" cuts	  
	  Int_t lab0=track0->GetLabel();
	  Int_t lab1=track1->GetLabel();
          TTreeSRedirector &cstream = *fDebugStreamer;
	  cstream<<"Curling2"<<
	    "iter="<<iter<<
	    "lab0="<<lab0<<
	    "lab1="<<lab1<<   
	    "Tr0.="<<track0<<
	    "Tr1.="<<track1<<
	    //
	    "r0="<<r0<<
	    "rc0="<<rc0<<
	    "fi0="<<fi0<<
	    "r1="<<r1<<
	    "rc1="<<rc1<<
	    "fi1="<<fi1<<
	    "dfi="<<dfi<<
	    "dtheta="<<dtheta<<
	    //
	    "npoints="<<npoints<<                      
	    "hangles0="<<hangles[0]<<
	    "hangles1="<<hangles[1]<<
	    "hangles2="<<hangles[2]<<                    
	    "xyz0="<<xyz0[2]<<
	    "xyzz1="<<xyz1[2]<<
	    "radius="<<radiusbest<<
	    "deltabest="<<deltabest<< 
	    "phase0="<<phase[ibest][0]<<
	    "phase1="<<phase[ibest][1]<<
	    "\n"; 	  	  

	}
      }
    }
  }
  delete [] helixes;
  if (AliTPCReconstructor::StreamLevel()>1) {
    AliInfo("Time for curling tracks removal");
    timer.Print();
  }
}


void  AliTPCtracker::FindKinks(TObjArray * array, AliESDEvent *esd)
{
  //
  //  find kinks
  //
  //
  // RS something is wrong in this routine: not all seeds are assigned to daughters and mothers array, but they all are queried
  // to check later

  TObjArray *kinks= new TObjArray(10000);
  //  TObjArray *v0s= new TObjArray(10000);
  Int_t nentries = array->GetEntriesFast();
  AliHelix *helixes      = new AliHelix[nentries];
  Int_t    *sign         = new Int_t[nentries];
  Int_t    *nclusters    = new Int_t[nentries];
  Float_t  *alpha        = new Float_t[nentries];
  AliKink  *kink         = new AliKink();
  Int_t      * usage     = new Int_t[nentries];
  Float_t  *zm           = new Float_t[nentries];
  Float_t  *z0           = new Float_t[nentries]; 
  Float_t  *fim          = new Float_t[nentries];
  Float_t  *shared       = new Float_t[nentries];
  Bool_t   *circular     = new Bool_t[nentries];
  Float_t *dca          = new Float_t[nentries];
  //const AliESDVertex * primvertex = esd->GetVertex();
  //
  //  nentries = array->GetEntriesFast();
  //
  
  //
  //
  for (Int_t i=0;i<nentries;i++){
    sign[i]=0;
    usage[i]=0;
    AliTPCseed* track = (AliTPCseed*)array->At(i);    
    if (!track) continue;
    track->SetCircular(0);
    shared[i] = kFALSE;
    track->UpdatePoints();
    if (( track->GetPoints()[2]- track->GetPoints()[0])>5 && track->GetPoints()[3]>0.8){
    }
    nclusters[i]=track->GetNumberOfClusters();
    alpha[i] = track->GetAlpha();
    new (&helixes[i]) AliHelix(*track);
    Double_t xyz[3];
    helixes[i].Evaluate(0,xyz);
    sign[i] = (track->GetC()>0) ? -1:1;
    Double_t x,y,z;
    x=160;
    if (track->GetProlongation(x,y,z)){
      zm[i]  = z;
      fim[i] = alpha[i]+TMath::ATan2(y,x);
    }
    else{
      zm[i]  = track->GetZ();
      fim[i] = alpha[i];
    }   
    z0[i]=1000;
    circular[i]= kFALSE;
    if (track->GetProlongation(0,y,z))  z0[i] = z;
    dca[i] = track->GetD(0,0);    
  }
  //
  //
  TStopwatch timer;
  timer.Start();
  Int_t ncandidates =0;
  Int_t nall =0;
  Int_t ntracks=0; 
  Double_t phase[2][2]={{0,0},{0,0}},radius[2]={0,0};

  //
  // Find circling track
  //
  for (Int_t i0=0;i0<nentries;i0++){
    AliTPCseed * track0 = (AliTPCseed*)array->At(i0);
    if (!track0) continue;    
    if (track0->GetNumberOfClusters()<40) continue;
    if (TMath::Abs(1./track0->GetC())>200) continue;
    for (Int_t i1=i0+1;i1<nentries;i1++){
      AliTPCseed * track1 = (AliTPCseed*)array->At(i1);
      if (!track1) continue;
      if (track1->GetNumberOfClusters()<40)                  continue;
      if ( TMath::Abs(track1->GetTgl()+track0->GetTgl())>0.1) continue;
      if (track0->GetBConstrain()&&track1->GetBConstrain()) continue;
      if (TMath::Abs(1./track1->GetC())>200) continue;
      if (track1->GetSigned1Pt()*track0->GetSigned1Pt()>0)      continue;
      if (track1->GetTgl()*track0->GetTgl()>0)      continue;
      if (TMath::Max(TMath::Abs(1./track0->GetC()),TMath::Abs(1./track1->GetC()))>190) continue;
      if (track0->GetBConstrain()&&track1->OneOverPt()<track0->OneOverPt()) continue; //returning - lower momenta
      if (track1->GetBConstrain()&&track0->OneOverPt()<track1->OneOverPt()) continue; //returning - lower momenta
      //
      Float_t mindcar = TMath::Min(TMath::Abs(dca[i0]),TMath::Abs(dca[i1]));
      if (mindcar<5)   continue;
      Float_t mindcaz = TMath::Min(TMath::Abs(z0[i0]-GetZ()),TMath::Abs(z0[i1]-GetZ()));
      if (mindcaz<5) continue;
      if (mindcar+mindcaz<20) continue;
      //
      //
      Float_t xc0 = helixes[i0].GetHelix(6);
      Float_t yc0 = helixes[i0].GetHelix(7);
      Float_t r0  = helixes[i0].GetHelix(8);
      Float_t xc1 = helixes[i1].GetHelix(6);
      Float_t yc1 = helixes[i1].GetHelix(7);
      Float_t r1  = helixes[i1].GetHelix(8);
	
      Float_t rmean = (r0+r1)*0.5;
      Float_t delta =TMath::Sqrt((xc1-xc0)*(xc1-xc0)+(yc1-yc0)*(yc1-yc0));
      //if (delta>30) continue;
      if (delta>rmean*0.25) continue;
      if (TMath::Abs(r0-r1)/rmean>0.3) continue; 
      //
      Int_t npoints = helixes[i0].GetRPHIintersections(helixes[i1], phase, radius,10);
      if (npoints==0) continue;
      helixes[i0].GetClosestPhases(helixes[i1], phase);
      //
      Double_t xyz0[3];
      Double_t xyz1[3];
      Double_t hangles[3];
      helixes[i0].Evaluate(phase[0][0],xyz0);
      helixes[i1].Evaluate(phase[0][1],xyz1);

      helixes[i0].GetAngle(phase[0][0],helixes[i1],phase[0][1],hangles);
      Double_t deltah[2],deltabest;
      if (hangles[2]<2.8) continue;
      if (npoints>0){
	Int_t ibest=0;
	helixes[i0].ParabolicDCA(helixes[i1],phase[0][0],phase[0][1],radius[0],deltah[0],2);
	if (npoints==2){
	  helixes[i0].ParabolicDCA(helixes[i1],phase[1][0],phase[1][1],radius[1],deltah[1],2);
	  if (deltah[1]<deltah[0]) ibest=1;
	}
	deltabest  = TMath::Sqrt(deltah[ibest]);
	helixes[i0].Evaluate(phase[ibest][0],xyz0);
	helixes[i1].Evaluate(phase[ibest][1],xyz1);
	helixes[i0].GetAngle(phase[ibest][0],helixes[i1],phase[ibest][1],hangles);
	Double_t radiusbest = TMath::Sqrt(radius[ibest]);
	//
	if (deltabest>6) continue;
	if (mindcar+mindcaz<40 && (hangles[2]<3.12||deltabest>3)) continue;
	Bool_t lsign =kFALSE;
	if (hangles[2]>3.06) lsign =kTRUE;
	//
	if (lsign){
	  circular[i0] = kTRUE;
	  circular[i1] = kTRUE;
	  if (track0->OneOverPt()<track1->OneOverPt()){
	    track0->SetCircular(track0->GetCircular()+1);
	    track1->SetCircular(track1->GetCircular()+2);
	  }
	  else{
	    track1->SetCircular(track1->GetCircular()+1);
	    track0->SetCircular(track0->GetCircular()+2);
	  }
	}		
	if (lsign&&((AliTPCReconstructor::StreamLevel()&kStreamFindCurling)>0)){	  
	  //debug stream	  
	  Int_t lab0=track0->GetLabel();
	  Int_t lab1=track1->GetLabel();
          TTreeSRedirector &cstream = *fDebugStreamer;
	  cstream<<"Curling"<<
	    "lab0="<<lab0<<
	    "lab1="<<lab1<<   
	    "Tr0.="<<track0<<
	    "Tr1.="<<track1<<	   
	    "dca0="<<dca[i0]<<
	    "dca1="<<dca[i1]<<
	    "mindcar="<<mindcar<<
	    "mindcaz="<<mindcaz<<
	    "delta="<<delta<<
	    "rmean="<<rmean<<
	    "npoints="<<npoints<<                      
	    "hangles0="<<hangles[0]<<
	    "hangles2="<<hangles[2]<<                    
	    "xyz0="<<xyz0[2]<<
	    "xyzz1="<<xyz1[2]<<
	    "z0="<<z0[i0]<<
	    "z1="<<z0[i1]<<
	    "radius="<<radiusbest<<
	    "deltabest="<<deltabest<< 
	    "phase0="<<phase[ibest][0]<<
	    "phase1="<<phase[ibest][1]<<
	    "\n"; 	  	  
	}
      }
    }
  }
  //
  //  Finf kinks loop
  // 
  //
  for (Int_t i =0;i<nentries;i++){
    if (sign[i]==0) continue;
    AliTPCseed * track0 = (AliTPCseed*)array->At(i);
    if (track0==0) {
      AliInfo("seed==0");
      continue;
    }
    ntracks++;
    //
    Double_t cradius0 = 40*40;
    Double_t cradius1 = 270*270;
    Double_t cdist1=8.;
    Double_t cdist2=8.;
    Double_t cdist3=0.55; 
    for (Int_t j =i+1;j<nentries;j++){
      nall++;
      if (sign[j]*sign[i]<1) continue;
      if ( (nclusters[i]+nclusters[j])>200) continue;
      if ( (nclusters[i]+nclusters[j])<80) continue;
      if ( TMath::Abs(zm[i]-zm[j])>60.) continue;
      if ( TMath::Abs(fim[i]-fim[j])>0.6 && TMath::Abs(fim[i]-fim[j])<5.7 ) continue;
      //AliTPCseed * track1 = (AliTPCseed*)array->At(j);  Double_t phase[2][2],radius[2];    
      Int_t npoints = helixes[i].GetRPHIintersections(helixes[j], phase, radius,20);
      if (npoints<1) continue;
      // cuts on radius      
      if (npoints==1){
	if (radius[0]<cradius0||radius[0]>cradius1) continue;
      }
      else{
	if ( (radius[0]<cradius0||radius[0]>cradius1) && (radius[1]<cradius0||radius[1]>cradius1) ) continue;
      }
      //      
      Double_t delta1=10000,delta2=10000;
      // cuts on the intersection radius
      helixes[i].LinearDCA(helixes[j],phase[0][0],phase[0][1],radius[0],delta1);
      if (radius[0]<20&&delta1<1) continue; //intersection at vertex
      if (radius[0]<10&&delta1<3) continue; //intersection at vertex
      if (npoints==2){ 
	helixes[i].LinearDCA(helixes[j],phase[1][0],phase[1][1],radius[1],delta2);
	if (radius[1]<20&&delta2<1) continue;  //intersection at vertex
	if (radius[1]<10&&delta2<3) continue;  //intersection at vertex	
      }
      //
      Double_t distance1 = TMath::Min(delta1,delta2);
      if (distance1>cdist1) continue;  // cut on DCA linear approximation
      //
      npoints = helixes[i].GetRPHIintersections(helixes[j], phase, radius,20);
      helixes[i].ParabolicDCA(helixes[j],phase[0][0],phase[0][1],radius[0],delta1);
      if (radius[0]<20&&delta1<1) continue; //intersection at vertex
      if (radius[0]<10&&delta1<3) continue; //intersection at vertex
      //
      if (npoints==2){ 
	helixes[i].ParabolicDCA(helixes[j],phase[1][0],phase[1][1],radius[1],delta2);	
	if (radius[1]<20&&delta2<1) continue;  //intersection at vertex
	if (radius[1]<10&&delta2<3) continue;  //intersection at vertex	
      }            
      distance1 = TMath::Min(delta1,delta2);
      Float_t rkink =0;
      if (delta1<delta2){
	rkink = TMath::Sqrt(radius[0]);
      }
      else{
	rkink = TMath::Sqrt(radius[1]);
      }
      if (distance1>cdist2) continue;
      //
      //
      AliTPCseed * track1 = (AliTPCseed*)array->At(j);
      //
      //
      Int_t row0 = GetRowNumber(rkink); 
      if (row0<10)  continue;
      if (row0>150) continue;
      //
      //
      Float_t dens00=-1,dens01=-1;
      Float_t dens10=-1,dens11=-1;
      //
      Int_t found,foundable,ishared;
      track0->GetClusterStatistic(0,row0-5, found, foundable,ishared,kFALSE);
      if (foundable>5) dens00 = Float_t(found)/Float_t(foundable);
      track0->GetClusterStatistic(row0+5,155, found, foundable,ishared,kFALSE);
      if (foundable>5) dens01 = Float_t(found)/Float_t(foundable);
      //
      track1->GetClusterStatistic(0,row0-5, found, foundable,ishared,kFALSE);
      if (foundable>10) dens10 = Float_t(found)/Float_t(foundable);
      track1->GetClusterStatistic(row0+5,155, found, foundable,ishared,kFALSE);
      if (foundable>10) dens11 = Float_t(found)/Float_t(foundable);
      //     
      if (dens00<dens10 && dens01<dens11) continue;
      if (dens00>dens10 && dens01>dens11) continue;
      if (TMath::Max(dens00,dens10)<0.1)  continue;
      if (TMath::Max(dens01,dens11)<0.3)  continue;
      //
      if (TMath::Min(dens00,dens10)>0.6)  continue;
      if (TMath::Min(dens01,dens11)>0.6)  continue;

      //
      AliTPCseed * ktrack0, *ktrack1;
      if (dens00>dens10){
	ktrack0 = track0;
	ktrack1 = track1;
      }
      else{
	ktrack0 = track1;
	ktrack1 = track0;
      }
      if (TMath::Abs(ktrack0->GetC())>5) continue; // cut on the curvature for mother particle
      AliExternalTrackParam paramm(*ktrack0);
      AliExternalTrackParam paramd(*ktrack1);
      if (row0>60&&ktrack1->GetReference().GetX()>90.)new (&paramd) AliExternalTrackParam(ktrack1->GetReference()); 
      //
      //
      kink->SetMother(paramm);
      kink->SetDaughter(paramd);
      kink->Update();

      Float_t x[3] = { static_cast<Float_t>(kink->GetPosition()[0]),static_cast<Float_t>(kink->GetPosition()[1]),static_cast<Float_t>(kink->GetPosition()[2])};
      Int_t index[4];
      fkParam->Transform0to1(x,index);
      fkParam->Transform1to2(x,index);
      row0 = GetRowNumber(x[0]); 

      if (kink->GetR()<100) continue;
      if (kink->GetR()>240) continue;
      if (kink->GetPosition()[2]/kink->GetR()>AliTPCReconstructor::GetCtgRange()) continue;  //out of fiducial volume
      if (kink->GetDistance()>cdist3) continue;
      Float_t dird = kink->GetDaughterP()[0]*kink->GetPosition()[0]+kink->GetDaughterP()[1]*kink->GetPosition()[1];  // rough direction estimate
      if (dird<0) continue;

      Float_t dirm = kink->GetMotherP()[0]*kink->GetPosition()[0]+kink->GetMotherP()[1]*kink->GetPosition()[1];  // rough direction estimate
      if (dirm<0) continue;
      Float_t mpt = TMath::Sqrt(kink->GetMotherP()[0]*kink->GetMotherP()[0]+kink->GetMotherP()[1]*kink->GetMotherP()[1]);
      if (mpt<0.2) continue;

      if (mpt<1){
	//for high momenta momentum not defined well in first iteration
	Double_t qt   =  TMath::Sin(kink->GetAngle(2))*ktrack1->GetP();
	if (qt>0.35) continue; 
      }
      
      kink->SetLabel(CookLabel(ktrack0,0.4,0,row0),0);
      kink->SetLabel(CookLabel(ktrack1,0.4,row0,160),1);
      if (dens00>dens10){
	kink->SetTPCDensity(dens00,0,0);
	kink->SetTPCDensity(dens01,0,1);
	kink->SetTPCDensity(dens10,1,0);
	kink->SetTPCDensity(dens11,1,1);
	kink->SetIndex(i,0);
	kink->SetIndex(j,1);
      }
      else{
	kink->SetTPCDensity(dens10,0,0);
	kink->SetTPCDensity(dens11,0,1);
	kink->SetTPCDensity(dens00,1,0);
	kink->SetTPCDensity(dens01,1,1);
	kink->SetIndex(j,0);
	kink->SetIndex(i,1);
      }

      if (mpt<1||kink->GetAngle(2)>0.1){
	//	angle and densities  not defined yet
	if (kink->GetTPCDensityFactor()<0.8) continue;
	if ((2-kink->GetTPCDensityFactor())*kink->GetDistance() >0.25) continue;
	if (kink->GetAngle(2)*ktrack0->GetP()<0.003) continue; //too small angle
	if (kink->GetAngle(2)>0.2&&kink->GetTPCDensityFactor()<1.15) continue;
	if (kink->GetAngle(2)>0.2&&kink->GetTPCDensity(0,1)>0.05) continue;

	Float_t criticalangle = track0->GetSigmaSnp2()+track0->GetSigmaTgl2();
	criticalangle+= track1->GetSigmaSnp2()+track1->GetSigmaTgl2();
	criticalangle= 3*TMath::Sqrt(criticalangle);
	if (criticalangle>0.02) criticalangle=0.02;
	if (kink->GetAngle(2)<criticalangle) continue;
      }
      //
      Int_t drow = Int_t(2.+0.5/(0.05+kink->GetAngle(2)));  // overlap region defined
      Float_t shapesum =0;
      Float_t sum = 0;
      for ( Int_t row = row0-drow; row<row0+drow;row++){
	if (row<0) continue;
	if (row>155) continue;
	if (ktrack0->GetClusterPointer(row)){
	  AliTPCTrackerPoint *point =ktrack0->GetTrackPoint(row);
	  shapesum+=point->GetSigmaY()+point->GetSigmaZ();
	  sum++;
	}
	if (ktrack1->GetClusterPointer(row)){
	  AliTPCTrackerPoint *point =ktrack1->GetTrackPoint(row);
	  shapesum+=point->GetSigmaY()+point->GetSigmaZ();
	  sum++;
	}	
      }
      if (sum<4){
	kink->SetShapeFactor(-1.);
      }
      else{
	kink->SetShapeFactor(shapesum/sum);
      }      
      //      esd->AddKink(kink);
      //
      //      kink->SetMother(paramm);
      //kink->SetDaughter(paramd);
 
      Double_t chi2P2 = paramm.GetParameter()[2]-paramd.GetParameter()[2];
      chi2P2*=chi2P2;
      chi2P2/=paramm.GetCovariance()[5]+paramd.GetCovariance()[5];
      Double_t chi2P3 = paramm.GetParameter()[3]-paramd.GetParameter()[3];
      chi2P3*=chi2P3;
      chi2P3/=paramm.GetCovariance()[9]+paramd.GetCovariance()[9];
      //
      if ((AliTPCReconstructor::StreamLevel()&kStreamFindKinks)>0) {   // flag: stream track infroamtion in the FindKinks method
	(*fDebugStreamer)<<"kinkLpt"<<
	  "chi2P2="<<chi2P2<<
	  "chi2P3="<<chi2P3<<
	  "p0.="<<&paramm<<
	  "p1.="<<&paramd<<
	  "k.="<<kink<<
	  "\n";
      }
      if ( chi2P2+chi2P3<AliTPCReconstructor::GetRecoParam()->GetKinkAngleCutChi2(0)){
	continue;
      }
      //
      kinks->AddLast(kink);
      kink = new AliKink;
      ncandidates++;
    }
  }
  //
  // sort the kinks according quality - and refit them towards vertex
  //
  Int_t       nkinks    = kinks->GetEntriesFast();
  Float_t    *quality   = new Float_t[nkinks];
  Int_t      *indexes   = new Int_t[nkinks];
  AliTPCseed *mothers   = new AliTPCseed[nkinks];
  AliTPCseed *daughters = new AliTPCseed[nkinks];
  //
  //
  for (Int_t i=0;i<nkinks;i++){
    quality[i] =100000;
    AliKink *kinkl = (AliKink*)kinks->At(i);
    //
    // refit kinks towards vertex
    // 
    Int_t index0 = kinkl->GetIndex(0);
    Int_t index1 = kinkl->GetIndex(1);
    AliTPCseed * ktrack0 = (AliTPCseed*)array->At(index0);
    AliTPCseed * ktrack1 = (AliTPCseed*)array->At(index1);
    //
    Int_t sumn=ktrack0->GetNumberOfClusters()+ktrack1->GetNumberOfClusters();
    //
    // Refit Kink under if too small angle
    //
    if (kinkl->GetAngle(2)<0.05){
      kinkl->SetTPCRow0(GetRowNumber(kinkl->GetR()));
      Int_t row0 = kinkl->GetTPCRow0();
      Int_t drow = Int_t(2.+0.5/(0.05+kinkl->GetAngle(2)));
      //
      //
      Int_t last  = row0-drow;
      if (last<40) last=40;
      if (last<ktrack0->GetFirstPoint()+25) last = ktrack0->GetFirstPoint()+25;
      AliTPCseed* seed0 = ReSeed(ktrack0,last,kFALSE);
      //
      //
      Int_t first = row0+drow;
      if (first>130) first=130;
      if (first>ktrack1->GetLastPoint()-25) first = TMath::Max(ktrack1->GetLastPoint()-25,30);
      AliTPCseed* seed1 = ReSeed(ktrack1,first,kTRUE);
      //
      if (seed0 && seed1){
	kinkl->SetStatus(1,8);
	if (RefitKink(*seed0,*seed1,*kinkl)) kinkl->SetStatus(1,9);
	row0 = GetRowNumber(kinkl->GetR());
	sumn = seed0->GetNumberOfClusters()+seed1->GetNumberOfClusters();
	mothers[i] = *seed0;
	daughters[i] = *seed1;
      }
      else{
	delete kinks->RemoveAt(i);
	if (seed0) MarkSeedFree( seed0 );
	if (seed1) MarkSeedFree( seed1 );
	continue;
      }
      if (kinkl->GetDistance()>0.5 || kinkl->GetR()<110 || kinkl->GetR()>240) {
	delete kinks->RemoveAt(i);
	if (seed0) MarkSeedFree( seed0 );
	if (seed1) MarkSeedFree( seed1 );
	continue;
      }
      //
      MarkSeedFree( seed0 );
      MarkSeedFree( seed1 );
    }
    //
    if (kinkl) quality[i] = 160*((0.1+kinkl->GetDistance())*(2.-kinkl->GetTPCDensityFactor()))/(sumn+40.);  //the longest -clossest will win
  }
  TMath::Sort(nkinks,quality,indexes,kFALSE);
  //
  //remove double find kinks
  //
  for (Int_t ikink0=1;ikink0<nkinks;ikink0++){
    AliKink * kink0 = (AliKink*) kinks->At(indexes[ikink0]);
    if (!kink0) continue;
    //
    for (Int_t ikink1=0;ikink1<ikink0;ikink1++){ 
      kink0 = (AliKink*) kinks->At(indexes[ikink0]);
      if (!kink0) continue;
      AliKink * kink1 = (AliKink*) kinks->At(indexes[ikink1]);
      if (!kink1) continue;
      // if not close kink continue
      if (TMath::Abs(kink1->GetPosition()[2]-kink0->GetPosition()[2])>10) continue;
      if (TMath::Abs(kink1->GetPosition()[1]-kink0->GetPosition()[1])>10) continue;
      if (TMath::Abs(kink1->GetPosition()[0]-kink0->GetPosition()[0])>10) continue;
      //
      AliTPCseed &mother0   = mothers[indexes[ikink0]];
      AliTPCseed &daughter0 = daughters[indexes[ikink0]];
      AliTPCseed &mother1   = mothers[indexes[ikink1]];
      AliTPCseed &daughter1 = daughters[indexes[ikink1]];
      Int_t row0 = (kink0->GetTPCRow0()+kink1->GetTPCRow0())/2;
      //
      Int_t same  = 0;
      Int_t both  = 0;
      Int_t samem = 0;
      Int_t bothm = 0;
      Int_t samed = 0;
      Int_t bothd = 0;
      //
      for (Int_t i=0;i<row0;i++){
	if (mother0.GetClusterIndex(i)>0 && mother1.GetClusterIndex(i)>0){
	  both++;
	  bothm++;
	  if (mother0.GetClusterIndex(i)==mother1.GetClusterIndex(i)){
	    same++;
	    samem++;
	  }
	}
      }

      for (Int_t i=row0;i<158;i++){
	//if (daughter0.GetClusterIndex(i)>0 && daughter0.GetClusterIndex(i)>0){ // RS: Bug? 
	if (daughter0.GetClusterIndex(i)>0 && daughter1.GetClusterIndex(i)>0){
	  both++;
	  bothd++;
	  if (mother0.GetClusterIndex(i)==mother1.GetClusterIndex(i)){
	    same++;
	    samed++;
	  }
	}
      }
      Float_t ratio = Float_t(same+1)/Float_t(both+1);
      Float_t ratiom = Float_t(samem+1)/Float_t(bothm+1);
      Float_t ratiod = Float_t(samed+1)/Float_t(bothd+1);
      if (ratio>0.3 && ratiom>0.5 &&ratiod>0.5) {
	Int_t sum0 = mother0.GetNumberOfClusters()+daughter0.GetNumberOfClusters();
	Int_t sum1 = mother1.GetNumberOfClusters()+daughter1.GetNumberOfClusters();
	if (sum1>sum0){
	  shared[kink0->GetIndex(0)]= kTRUE;
	  shared[kink0->GetIndex(1)]= kTRUE;	  
	  delete kinks->RemoveAt(indexes[ikink0]);
	  break;
	}
	else{
	  shared[kink1->GetIndex(0)]= kTRUE;
	  shared[kink1->GetIndex(1)]= kTRUE;	  
	  delete kinks->RemoveAt(indexes[ikink1]);
	}
      }
    }
  }


  for (Int_t i=0;i<nkinks;i++){
    AliKink * kinkl = (AliKink*) kinks->At(indexes[i]);
    if (!kinkl) continue;
    kinkl->SetTPCRow0(GetRowNumber(kinkl->GetR()));
    Int_t index0 = kinkl->GetIndex(0);
    Int_t index1 = kinkl->GetIndex(1);
    if (circular[index0]||(circular[index1]&&kinkl->GetDistance()>0.2)) continue;
    kinkl->SetMultiple(usage[index0],0);
    kinkl->SetMultiple(usage[index1],1);
    if (kinkl->GetMultiple()[0]+kinkl->GetMultiple()[1]>2) continue;
    if (kinkl->GetMultiple()[0]+kinkl->GetMultiple()[1]>0 && quality[indexes[i]]>0.2) continue;
    if (kinkl->GetMultiple()[0]+kinkl->GetMultiple()[1]>0 && kinkl->GetDistance()>0.2) continue;
    if (circular[index0]||(circular[index1]&&kinkl->GetDistance()>0.1)) continue;

    AliTPCseed * ktrack0 = (AliTPCseed*)array->At(index0);
    AliTPCseed * ktrack1 = (AliTPCseed*)array->At(index1);
    if (!ktrack0 || !ktrack1) continue;
    Int_t index = esd->AddKink(kinkl);
    //
    //
    if ( ktrack0->GetKinkIndex(0)==0 && ktrack1->GetKinkIndex(0)==0) {  //best kink
      if (mothers[indexes[i]].GetNumberOfClusters()>20 && daughters[indexes[i]].GetNumberOfClusters()>20 && (mothers[indexes[i]].GetNumberOfClusters()+daughters[indexes[i]].GetNumberOfClusters())>100){
	*ktrack0 = mothers[indexes[i]];
	*ktrack1 = daughters[indexes[i]];
      }
    }
    //
    ktrack0->SetKinkIndex(usage[index0],-(index+1));
    ktrack1->SetKinkIndex(usage[index1], (index+1));
    usage[index0]++;
    usage[index1]++;
  }
  //
  // Remove tracks corresponding to shared kink's
  //
  for (Int_t i=0;i<nentries;i++){
    AliTPCseed * track0 = (AliTPCseed*)array->At(i);
    if (!track0) continue;
    if (track0->GetKinkIndex(0)!=0) continue;
    if (shared[i]) MarkSeedFree( array->RemoveAt(i) );
  }

  //
  //
  RemoveUsed2(array,0.5,0.4,30);
  UnsignClusters();
  for (Int_t i=0;i<nentries;i++){
    AliTPCseed * track0 = (AliTPCseed*)array->At(i);
    if (!track0) continue;
    track0->CookdEdx(0.02,0.6);
    track0->CookPID();
  }
  //
  for (Int_t i=0;i<nentries;i++){
    AliTPCseed * track0 = (AliTPCseed*)array->At(i);
    if (!track0) continue;
    if (track0->Pt()<1.4) continue;
    //remove double high momenta tracks - overlapped with kink candidates
    Int_t ishared=0;
    Int_t all   =0;
    for (Int_t icl=track0->GetFirstPoint();icl<track0->GetLastPoint(); icl++){
      if (track0->GetClusterPointer(icl)!=0){
	all++;
	if (track0->GetClusterPointer(icl)->IsUsed(10)) ishared++;
      }
    }
    if (Float_t(ishared+1)/Float_t(all+1)>0.5) {  
      MarkSeedFree( array->RemoveAt(i) );
      continue;
    }
    //
    if (track0->GetKinkIndex(0)!=0) continue;
    if (track0->GetNumberOfClusters()<80) continue;

    AliTPCseed *pmother = new AliTPCseed();
    AliTPCseed *pdaughter = new AliTPCseed();
    AliKink *pkink = new AliKink;

    AliTPCseed & mother = *pmother;
    AliTPCseed & daughter = *pdaughter;
    AliKink & kinkl = *pkink;
    if (CheckKinkPoint(track0,mother,daughter, kinkl)){
      if (mother.GetNumberOfClusters()<30||daughter.GetNumberOfClusters()<20) {
	delete pmother;
	delete pdaughter;
	delete pkink;
	continue;  //too short tracks
      }
      if (mother.Pt()<1.4) {
	delete pmother;
	delete pdaughter;
	delete pkink;
	continue;
      }
      Int_t row0= kinkl.GetTPCRow0();
      if (kinkl.GetDistance()>0.5 || kinkl.GetR()<110. || kinkl.GetR()>240.) {
	delete pmother;
	delete pdaughter;
	delete pkink;
	continue;
      }
      //
      Int_t index = esd->AddKink(&kinkl);      
      mother.SetKinkIndex(0,-(index+1));
      daughter.SetKinkIndex(0,index+1);
      if (mother.GetNumberOfClusters()>50) {
	MarkSeedFree( array->RemoveAt(i) );
	AliTPCseed* mtc = new( NextFreeSeed() ) AliTPCseed(mother);
	mtc->SetPoolID(fLastSeedID);
	array->AddAt(mtc,i);
      }
      else{
	AliTPCseed* mtc = new( NextFreeSeed() ) AliTPCseed(mother);
	mtc->SetPoolID(fLastSeedID);
	array->AddLast(mtc);
      }
      AliTPCseed* dtc = new( NextFreeSeed() ) AliTPCseed(daughter);
      dtc->SetPoolID(fLastSeedID);
      array->AddLast(dtc);      
      for (Int_t icl=0;icl<row0;icl++) {
	if (mother.GetClusterPointer(icl)) mother.GetClusterPointer(icl)->Use(20);
      }
      //
      for (Int_t icl=row0;icl<158;icl++) {
	if (daughter.GetClusterPointer(icl)) daughter.GetClusterPointer(icl)->Use(20);
      }
      //
    }
    delete pmother;
    delete pdaughter;
    delete pkink;
  }

  delete [] daughters;
  delete [] mothers;
  //
  //
  delete [] dca;
  delete []circular;
  delete []shared;
  delete []quality;
  delete []indexes;
  //
  delete kink;
  delete[]fim;
  delete[] zm;
  delete[] z0;
  delete [] usage;
  delete[] alpha;
  delete[] nclusters;
  delete[] sign;
  delete[] helixes;
  kinks->Delete();
  delete kinks;

  AliInfo(Form("Ncandidates=\t%d\t%d\t%d\t%d\n",esd->GetNumberOfKinks(),ncandidates,ntracks,nall));
  timer.Print();
}


/*
void  AliTPCtracker::FindKinks(TObjArray * array, AliESDEvent *esd)
{
  //
  //  find kinks
  //
  //

  TObjArray *kinks= new TObjArray(10000);
  //  TObjArray *v0s= new TObjArray(10000);
  Int_t nentries = array->GetEntriesFast();
  AliHelix *helixes      = new AliHelix[nentries];
  Int_t    *sign         = new Int_t[nentries];
  Int_t    *nclusters    = new Int_t[nentries];
  Float_t  *alpha        = new Float_t[nentries];
  AliKink  *kink         = new AliKink();
  Int_t      * usage     = new Int_t[nentries];
  Float_t  *zm           = new Float_t[nentries];
  Float_t  *z0           = new Float_t[nentries]; 
  Float_t  *fim          = new Float_t[nentries];
  Float_t  *shared       = new Float_t[nentries];
  Bool_t   *circular     = new Bool_t[nentries];
  Float_t *dca          = new Float_t[nentries];
  //const AliESDVertex * primvertex = esd->GetVertex();
  //
  //  nentries = array->GetEntriesFast();
  //
  
  //
  //
  for (Int_t i=0;i<nentries;i++){
    sign[i]=0;
    usage[i]=0;
    AliTPCseed* track = (AliTPCseed*)array->At(i);    
    if (!track) continue;
    track->SetCircular(0);
    shared[i] = kFALSE;
    track->UpdatePoints();
    if (( track->GetPoints()[2]- track->GetPoints()[0])>5 && track->GetPoints()[3]>0.8){
    }
    nclusters[i]=track->GetNumberOfClusters();
    alpha[i] = track->GetAlpha();
    new (&helixes[i]) AliHelix(*track);
    Double_t xyz[3];
    helixes[i].Evaluate(0,xyz);
    sign[i] = (track->GetC()>0) ? -1:1;
    Double_t x,y,z;
    x=160;
    if (track->GetProlongation(x,y,z)){
      zm[i]  = z;
      fim[i] = alpha[i]+TMath::ATan2(y,x);
    }
    else{
      zm[i]  = track->GetZ();
      fim[i] = alpha[i];
    }   
    z0[i]=1000;
    circular[i]= kFALSE;
    if (track->GetProlongation(0,y,z))  z0[i] = z;
    dca[i] = track->GetD(0,0);    
  }
  //
  //
  TStopwatch timer;
  timer.Start();
  Int_t ncandidates =0;
  Int_t nall =0;
  Int_t ntracks=0; 
  Double_t phase[2][2]={{0,0},{0,0}},radius[2]={0,0};

  //
  // Find circling track
  //
  for (Int_t i0=0;i0<nentries;i0++){
    AliTPCseed * track0 = (AliTPCseed*)array->At(i0);
    if (!track0) continue;    
    if (track0->GetNumberOfClusters()<40) continue;
    if (TMath::Abs(1./track0->GetC())>200) continue;
    for (Int_t i1=i0+1;i1<nentries;i1++){
      AliTPCseed * track1 = (AliTPCseed*)array->At(i1);
      if (!track1) continue;
      if (track1->GetNumberOfClusters()<40)                  continue;
      if ( TMath::Abs(track1->GetTgl()+track0->GetTgl())>0.1) continue;
      if (track0->GetBConstrain()&&track1->GetBConstrain()) continue;
      if (TMath::Abs(1./track1->GetC())>200) continue;
      if (track1->GetSigned1Pt()*track0->GetSigned1Pt()>0)      continue;
      if (track1->GetTgl()*track0->GetTgl()>0)      continue;
      if (TMath::Max(TMath::Abs(1./track0->GetC()),TMath::Abs(1./track1->GetC()))>190) continue;
      if (track0->GetBConstrain()&&track1->OneOverPt()<track0->OneOverPt()) continue; //returning - lower momenta
      if (track1->GetBConstrain()&&track0->OneOverPt()<track1->OneOverPt()) continue; //returning - lower momenta
      //
      Float_t mindcar = TMath::Min(TMath::Abs(dca[i0]),TMath::Abs(dca[i1]));
      if (mindcar<5)   continue;
      Float_t mindcaz = TMath::Min(TMath::Abs(z0[i0]-GetZ()),TMath::Abs(z0[i1]-GetZ()));
      if (mindcaz<5) continue;
      if (mindcar+mindcaz<20) continue;
      //
      //
      Float_t xc0 = helixes[i0].GetHelix(6);
      Float_t yc0 = helixes[i0].GetHelix(7);
      Float_t r0  = helixes[i0].GetHelix(8);
      Float_t xc1 = helixes[i1].GetHelix(6);
      Float_t yc1 = helixes[i1].GetHelix(7);
      Float_t r1  = helixes[i1].GetHelix(8);
	
      Float_t rmean = (r0+r1)*0.5;
      Float_t delta =TMath::Sqrt((xc1-xc0)*(xc1-xc0)+(yc1-yc0)*(yc1-yc0));
      //if (delta>30) continue;
      if (delta>rmean*0.25) continue;
      if (TMath::Abs(r0-r1)/rmean>0.3) continue; 
      //
      Int_t npoints = helixes[i0].GetRPHIintersections(helixes[i1], phase, radius,10);
      if (npoints==0) continue;
      helixes[i0].GetClosestPhases(helixes[i1], phase);
      //
      Double_t xyz0[3];
      Double_t xyz1[3];
      Double_t hangles[3];
      helixes[i0].Evaluate(phase[0][0],xyz0);
      helixes[i1].Evaluate(phase[0][1],xyz1);

      helixes[i0].GetAngle(phase[0][0],helixes[i1],phase[0][1],hangles);
      Double_t deltah[2],deltabest;
      if (hangles[2]<2.8) continue;
      if (npoints>0){
	Int_t ibest=0;
	helixes[i0].ParabolicDCA(helixes[i1],phase[0][0],phase[0][1],radius[0],deltah[0],2);
	if (npoints==2){
	  helixes[i0].ParabolicDCA(helixes[i1],phase[1][0],phase[1][1],radius[1],deltah[1],2);
	  if (deltah[1]<deltah[0]) ibest=1;
	}
	deltabest  = TMath::Sqrt(deltah[ibest]);
	helixes[i0].Evaluate(phase[ibest][0],xyz0);
	helixes[i1].Evaluate(phase[ibest][1],xyz1);
	helixes[i0].GetAngle(phase[ibest][0],helixes[i1],phase[ibest][1],hangles);
	Double_t radiusbest = TMath::Sqrt(radius[ibest]);
	//
	if (deltabest>6) continue;
	if (mindcar+mindcaz<40 && (hangles[2]<3.12||deltabest>3)) continue;
	Bool_t lsign =kFALSE;
	if (hangles[2]>3.06) lsign =kTRUE;
	//
	if (lsign){
	  circular[i0] = kTRUE;
	  circular[i1] = kTRUE;
	  if (track0->OneOverPt()<track1->OneOverPt()){
	    track0->SetCircular(track0->GetCircular()+1);
	    track1->SetCircular(track1->GetCircular()+2);
	  }
	  else{
	    track1->SetCircular(track1->GetCircular()+1);
	    track0->SetCircular(track0->GetCircular()+2);
	  }
	}		
	if (lsign&&((AliTPCReconstructor::StreamLevel()&kStreamFindKinks)>0)){// flag: stream track infroamtion in the FindKinks method	  
	  //debug stream	  
	  Int_t lab0=track0->GetLabel();
	  Int_t lab1=track1->GetLabel();
          TTreeSRedirector &cstream = *fDebugStreamer;
	  cstream<<"Curling"<<
	    "lab0="<<lab0<<
	    "lab1="<<lab1<<   
	    "Tr0.="<<track0<<
	    "Tr1.="<<track1<<	   
	    "dca0="<<dca[i0]<<
	    "dca1="<<dca[i1]<<
	    "mindcar="<<mindcar<<
	    "mindcaz="<<mindcaz<<
	    "delta="<<delta<<
	    "rmean="<<rmean<<
	    "npoints="<<npoints<<                      
	    "hangles0="<<hangles[0]<<
	    "hangles2="<<hangles[2]<<                    
	    "xyz0="<<xyz0[2]<<
	    "xyzz1="<<xyz1[2]<<
	    "z0="<<z0[i0]<<
	    "z1="<<z0[i1]<<
	    "radius="<<radiusbest<<
	    "deltabest="<<deltabest<< 
	    "phase0="<<phase[ibest][0]<<
	    "phase1="<<phase[ibest][1]<<
	    "\n"; 	  	  
	}
      }
    }
  }
  //
  //  Finf kinks loop
  // 
  //
  for (Int_t i =0;i<nentries;i++){
    if (sign[i]==0) continue;
    AliTPCseed * track0 = (AliTPCseed*)array->At(i);
    if (track0==0) {
      AliInfo("seed==0");
      continue;
    }
    ntracks++;
    //
    Double_t cradius0 = 40*40;
    Double_t cradius1 = 270*270;
    Double_t cdist1=8.;
    Double_t cdist2=8.;
    Double_t cdist3=0.55; 
    for (Int_t j =i+1;j<nentries;j++){
      nall++;
      if (sign[j]*sign[i]<1) continue;
      if ( (nclusters[i]+nclusters[j])>200) continue;
      if ( (nclusters[i]+nclusters[j])<80) continue;
      if ( TMath::Abs(zm[i]-zm[j])>60.) continue;
      if ( TMath::Abs(fim[i]-fim[j])>0.6 && TMath::Abs(fim[i]-fim[j])<5.7 ) continue;
      //AliTPCseed * track1 = (AliTPCseed*)array->At(j);  Double_t phase[2][2],radius[2];    
      Int_t npoints = helixes[i].GetRPHIintersections(helixes[j], phase, radius,20);
      if (npoints<1) continue;
      // cuts on radius      
      if (npoints==1){
	if (radius[0]<cradius0||radius[0]>cradius1) continue;
      }
      else{
	if ( (radius[0]<cradius0||radius[0]>cradius1) && (radius[1]<cradius0||radius[1]>cradius1) ) continue;
      }
      //      
      Double_t delta1=10000,delta2=10000;
      // cuts on the intersection radius
      helixes[i].LinearDCA(helixes[j],phase[0][0],phase[0][1],radius[0],delta1);
      if (radius[0]<20&&delta1<1) continue; //intersection at vertex
      if (radius[0]<10&&delta1<3) continue; //intersection at vertex
      if (npoints==2){ 
	helixes[i].LinearDCA(helixes[j],phase[1][0],phase[1][1],radius[1],delta2);
	if (radius[1]<20&&delta2<1) continue;  //intersection at vertex
	if (radius[1]<10&&delta2<3) continue;  //intersection at vertex	
      }
      //
      Double_t distance1 = TMath::Min(delta1,delta2);
      if (distance1>cdist1) continue;  // cut on DCA linear approximation
      //
      npoints = helixes[i].GetRPHIintersections(helixes[j], phase, radius,20);
      helixes[i].ParabolicDCA(helixes[j],phase[0][0],phase[0][1],radius[0],delta1);
      if (radius[0]<20&&delta1<1) continue; //intersection at vertex
      if (radius[0]<10&&delta1<3) continue; //intersection at vertex
      //
      if (npoints==2){ 
	helixes[i].ParabolicDCA(helixes[j],phase[1][0],phase[1][1],radius[1],delta2);	
	if (radius[1]<20&&delta2<1) continue;  //intersection at vertex
	if (radius[1]<10&&delta2<3) continue;  //intersection at vertex	
      }            
      distance1 = TMath::Min(delta1,delta2);
      Float_t rkink =0;
      if (delta1<delta2){
	rkink = TMath::Sqrt(radius[0]);
      }
      else{
	rkink = TMath::Sqrt(radius[1]);
      }
      if (distance1>cdist2) continue;
      //
      //
      AliTPCseed * track1 = (AliTPCseed*)array->At(j);
      //
      //
      Int_t row0 = GetRowNumber(rkink); 
      if (row0<10)  continue;
      if (row0>150) continue;
      //
      //
      Float_t dens00=-1,dens01=-1;
      Float_t dens10=-1,dens11=-1;
      //
      Int_t found,foundable,ishared;
      track0->GetClusterStatistic(0,row0-5, found, foundable,ishared,kFALSE);
      if (foundable>5) dens00 = Float_t(found)/Float_t(foundable);
      track0->GetClusterStatistic(row0+5,155, found, foundable,ishared,kFALSE);
      if (foundable>5) dens01 = Float_t(found)/Float_t(foundable);
      //
      track1->GetClusterStatistic(0,row0-5, found, foundable,ishared,kFALSE);
      if (foundable>10) dens10 = Float_t(found)/Float_t(foundable);
      track1->GetClusterStatistic(row0+5,155, found, foundable,ishared,kFALSE);
      if (foundable>10) dens11 = Float_t(found)/Float_t(foundable);
      //     
      if (dens00<dens10 && dens01<dens11) continue;
      if (dens00>dens10 && dens01>dens11) continue;
      if (TMath::Max(dens00,dens10)<0.1)  continue;
      if (TMath::Max(dens01,dens11)<0.3)  continue;
      //
      if (TMath::Min(dens00,dens10)>0.6)  continue;
      if (TMath::Min(dens01,dens11)>0.6)  continue;

      //
      AliTPCseed * ktrack0, *ktrack1;
      if (dens00>dens10){
	ktrack0 = track0;
	ktrack1 = track1;
      }
      else{
	ktrack0 = track1;
	ktrack1 = track0;
      }
      if (TMath::Abs(ktrack0->GetC())>5) continue; // cut on the curvature for mother particle
      AliExternalTrackParam paramm(*ktrack0);
      AliExternalTrackParam paramd(*ktrack1);
      if (row0>60&&ktrack1->GetReference().GetX()>90.)new (&paramd) AliExternalTrackParam(ktrack1->GetReference()); 
      //
      //
      kink->SetMother(paramm);
      kink->SetDaughter(paramd);
      kink->Update();

      Float_t x[3] = { static_cast<Float_t>(kink->GetPosition()[0]),static_cast<Float_t>(kink->GetPosition()[1]),static_cast<Float_t>(kink->GetPosition()[2])};
      Int_t index[4];
      fkParam->Transform0to1(x,index);
      fkParam->Transform1to2(x,index);
      row0 = GetRowNumber(x[0]); 

      if (kink->GetR()<100) continue;
      if (kink->GetR()>240) continue;
      if (kink->GetPosition()[2]/kink->GetR()>AliTPCReconstructor::GetCtgRange()) continue;  //out of fiducial volume
      if (kink->GetDistance()>cdist3) continue;
      Float_t dird = kink->GetDaughterP()[0]*kink->GetPosition()[0]+kink->GetDaughterP()[1]*kink->GetPosition()[1];  // rough direction estimate
      if (dird<0) continue;

      Float_t dirm = kink->GetMotherP()[0]*kink->GetPosition()[0]+kink->GetMotherP()[1]*kink->GetPosition()[1];  // rough direction estimate
      if (dirm<0) continue;
      Float_t mpt = TMath::Sqrt(kink->GetMotherP()[0]*kink->GetMotherP()[0]+kink->GetMotherP()[1]*kink->GetMotherP()[1]);
      if (mpt<0.2) continue;

      if (mpt<1){
	//for high momenta momentum not defined well in first iteration
	Double_t qt   =  TMath::Sin(kink->GetAngle(2))*ktrack1->GetP();
	if (qt>0.35) continue; 
      }
      
      kink->SetLabel(CookLabel(ktrack0,0.4,0,row0),0);
      kink->SetLabel(CookLabel(ktrack1,0.4,row0,160),1);
      if (dens00>dens10){
	kink->SetTPCDensity(dens00,0,0);
	kink->SetTPCDensity(dens01,0,1);
	kink->SetTPCDensity(dens10,1,0);
	kink->SetTPCDensity(dens11,1,1);
	kink->SetIndex(i,0);
	kink->SetIndex(j,1);
      }
      else{
	kink->SetTPCDensity(dens10,0,0);
	kink->SetTPCDensity(dens11,0,1);
	kink->SetTPCDensity(dens00,1,0);
	kink->SetTPCDensity(dens01,1,1);
	kink->SetIndex(j,0);
	kink->SetIndex(i,1);
      }

      if (mpt<1||kink->GetAngle(2)>0.1){
	//	angle and densities  not defined yet
	if (kink->GetTPCDensityFactor()<0.8) continue;
	if ((2-kink->GetTPCDensityFactor())*kink->GetDistance() >0.25) continue;
	if (kink->GetAngle(2)*ktrack0->GetP()<0.003) continue; //too small angle
	if (kink->GetAngle(2)>0.2&&kink->GetTPCDensityFactor()<1.15) continue;
	if (kink->GetAngle(2)>0.2&&kink->GetTPCDensity(0,1)>0.05) continue;

	Float_t criticalangle = track0->GetSigmaSnp2()+track0->GetSigmaTgl2();
	criticalangle+= track1->GetSigmaSnp2()+track1->GetSigmaTgl2();
	criticalangle= 3*TMath::Sqrt(criticalangle);
	if (criticalangle>0.02) criticalangle=0.02;
	if (kink->GetAngle(2)<criticalangle) continue;
      }
      //
      Int_t drow = Int_t(2.+0.5/(0.05+kink->GetAngle(2)));  // overlap region defined
      Float_t shapesum =0;
      Float_t sum = 0;
      for ( Int_t row = row0-drow; row<row0+drow;row++){
	if (row<0) continue;
	if (row>155) continue;
	if (ktrack0->GetClusterPointer(row)){
	  AliTPCTrackerPoint *point =ktrack0->GetTrackPoint(row);
	  shapesum+=point->GetSigmaY()+point->GetSigmaZ();
	  sum++;
	}
	if (ktrack1->GetClusterPointer(row)){
	  AliTPCTrackerPoint *point =ktrack1->GetTrackPoint(row);
	  shapesum+=point->GetSigmaY()+point->GetSigmaZ();
	  sum++;
	}	
      }
      if (sum<4){
	kink->SetShapeFactor(-1.);
      }
      else{
	kink->SetShapeFactor(shapesum/sum);
      }      
      //      esd->AddKink(kink);
      //
      //      kink->SetMother(paramm);
      //kink->SetDaughter(paramd);
 
      Double_t chi2P2 = paramm.GetParameter()[2]-paramd.GetParameter()[2];
      chi2P2*=chi2P2;
      chi2P2/=paramm.GetCovariance()[5]+paramd.GetCovariance()[5];
      Double_t chi2P3 = paramm.GetParameter()[3]-paramd.GetParameter()[3];
      chi2P3*=chi2P3;
      chi2P3/=paramm.GetCovariance()[9]+paramd.GetCovariance()[9];
      //
      if (AliTPCReconstructor::StreamLevel()&kStreamFindKinks) {// flag: stream track infroamtion in the FindKinks method
	(*fDebugStreamer)<<"kinkLpt"<<
	  "chi2P2="<<chi2P2<<
	  "chi2P3="<<chi2P3<<
	  "p0.="<<&paramm<<
	  "p1.="<<&paramd<<
	  "k.="<<kink<<
	  "\n";
      }
      if ( chi2P2+chi2P3<AliTPCReconstructor::GetRecoParam()->GetKinkAngleCutChi2(0)){
	continue;
      }
      //
      kinks->AddLast(kink);
      kink = new AliKink;
      ncandidates++;
    }
  }
  //
  // sort the kinks according quality - and refit them towards vertex
  //
  Int_t       nkinks    = kinks->GetEntriesFast();
  Float_t    *quality   = new Float_t[nkinks];
  Int_t      *indexes   = new Int_t[nkinks];
  AliTPCseed **mothers   = new AliTPCseed*[nkinks]; memset(mothers,   0, nkinks*sizeof(AliTPCseed*));
  AliTPCseed **daughters = new AliTPCseed*[nkinks]; memset(daughters, 0, nkinks*sizeof(AliTPCseed*));
  //
  //
  for (Int_t i=0;i<nkinks;i++){
    quality[i] =100000;
    AliKink *kinkl = (AliKink*)kinks->At(i);
    //
    // refit kinks towards vertex
    // 
    Int_t index0 = kinkl->GetIndex(0);
    Int_t index1 = kinkl->GetIndex(1);
    AliTPCseed * ktrack0 = (AliTPCseed*)array->At(index0);
    AliTPCseed * ktrack1 = (AliTPCseed*)array->At(index1);
    //
    Int_t sumn=ktrack0->GetNumberOfClusters()+ktrack1->GetNumberOfClusters();
    //
    // Refit Kink under if too small angle
    //
    if (kinkl->GetAngle(2)<0.05){
      kinkl->SetTPCRow0(GetRowNumber(kinkl->GetR()));
      Int_t row0 = kinkl->GetTPCRow0();
      Int_t drow = Int_t(2.+0.5/(0.05+kinkl->GetAngle(2)));
      //
      //
      Int_t last  = row0-drow;
      if (last<40) last=40;
      if (last<ktrack0->GetFirstPoint()+25) last = ktrack0->GetFirstPoint()+25;
      AliTPCseed* seed0 = ReSeed(ktrack0,last,kFALSE);
      //
      //
      Int_t first = row0+drow;
      if (first>130) first=130;
      if (first>ktrack1->GetLastPoint()-25) first = TMath::Max(ktrack1->GetLastPoint()-25,30);
      AliTPCseed* seed1 = ReSeed(ktrack1,first,kTRUE);
      //
      if (seed0 && seed1){
	kinkl->SetStatus(1,8);
	if (RefitKink(*seed0,*seed1,*kinkl)) kinkl->SetStatus(1,9);
	row0 = GetRowNumber(kinkl->GetR());
	sumn = seed0->GetNumberOfClusters()+seed1->GetNumberOfClusters();
	mothers[i] = new ( NextFreeSeed() ) AliTPCseed(*seed0);
	mothers[i]->SetPoolID(fLastSeedID);
	daughters[i] = new (NextFreeSeed() ) AliTPCseed(*seed1);
	daughters[i]->SetPoolID(fLastSeedID);
      }
      else{
	delete kinks->RemoveAt(i);
	if (seed0) MarkSeedFree( seed0 );
	if (seed1) MarkSeedFree( seed1 );
	continue;
      }
      if (kinkl->GetDistance()>0.5 || kinkl->GetR()<110 || kinkl->GetR()>240) {
	delete kinks->RemoveAt(i);
	if (seed0) MarkSeedFree( seed0 );
	if (seed1) MarkSeedFree( seed1 );
	continue;
      }
      //
      MarkSeedFree( seed0 );
      MarkSeedFree( seed1 );
    }
    //
    if (kinkl) quality[i] = 160*((0.1+kinkl->GetDistance())*(2.-kinkl->GetTPCDensityFactor()))/(sumn+40.);  //the longest -clossest will win
  }
  TMath::Sort(nkinks,quality,indexes,kFALSE);
  //
  //remove double find kinks
  //
  for (Int_t ikink0=1;ikink0<nkinks;ikink0++){
    AliKink * kink0 = (AliKink*) kinks->At(indexes[ikink0]);
    if (!kink0) continue;
    //
    for (Int_t ikink1=0;ikink1<ikink0;ikink1++){ 
      kink0 = (AliKink*) kinks->At(indexes[ikink0]);
      if (!kink0) continue;
      AliKink * kink1 = (AliKink*) kinks->At(indexes[ikink1]);
      if (!kink1) continue;
      // if not close kink continue
      if (TMath::Abs(kink1->GetPosition()[2]-kink0->GetPosition()[2])>10) continue;
      if (TMath::Abs(kink1->GetPosition()[1]-kink0->GetPosition()[1])>10) continue;
      if (TMath::Abs(kink1->GetPosition()[0]-kink0->GetPosition()[0])>10) continue;
      //
      AliTPCseed &mother0   = *mothers[indexes[ikink0]];
      AliTPCseed &daughter0 = *daughters[indexes[ikink0]];
      AliTPCseed &mother1   = *mothers[indexes[ikink1]];
      AliTPCseed &daughter1 = *daughters[indexes[ikink1]];
      Int_t row0 = (kink0->GetTPCRow0()+kink1->GetTPCRow0())/2;
      //
      Int_t same  = 0;
      Int_t both  = 0;
      Int_t samem = 0;
      Int_t bothm = 0;
      Int_t samed = 0;
      Int_t bothd = 0;
      //
      for (Int_t i=0;i<row0;i++){
	if (mother0.GetClusterIndex(i)>0 && mother1.GetClusterIndex(i)>0){
	  both++;
	  bothm++;
	  if (mother0.GetClusterIndex(i)==mother1.GetClusterIndex(i)){
	    same++;
	    samem++;
	  }
	}
      }

      for (Int_t i=row0;i<158;i++){
	//if (daughter0.GetClusterIndex(i)>0 && daughter0.GetClusterIndex(i)>0){ // RS: Bug? 
	if (daughter0.GetClusterIndex(i)>0 && daughter1.GetClusterIndex(i)>0){
	  both++;
	  bothd++;
	  if (mother0.GetClusterIndex(i)==mother1.GetClusterIndex(i)){
	    same++;
	    samed++;
	  }
	}
      }
      Float_t ratio = Float_t(same+1)/Float_t(both+1);
      Float_t ratiom = Float_t(samem+1)/Float_t(bothm+1);
      Float_t ratiod = Float_t(samed+1)/Float_t(bothd+1);
      if (ratio>0.3 && ratiom>0.5 &&ratiod>0.5) {
	Int_t sum0 = mother0.GetNumberOfClusters()+daughter0.GetNumberOfClusters();
	Int_t sum1 = mother1.GetNumberOfClusters()+daughter1.GetNumberOfClusters();
	if (sum1>sum0){
	  shared[kink0->GetIndex(0)]= kTRUE;
	  shared[kink0->GetIndex(1)]= kTRUE;	  
	  delete kinks->RemoveAt(indexes[ikink0]);
	  break;
	}
	else{
	  shared[kink1->GetIndex(0)]= kTRUE;
	  shared[kink1->GetIndex(1)]= kTRUE;	  
	  delete kinks->RemoveAt(indexes[ikink1]);
	}
      }
    }
  }


  for (Int_t i=0;i<nkinks;i++){
    AliKink * kinkl = (AliKink*) kinks->At(indexes[i]);
    if (!kinkl) continue;
    kinkl->SetTPCRow0(GetRowNumber(kinkl->GetR()));
    Int_t index0 = kinkl->GetIndex(0);
    Int_t index1 = kinkl->GetIndex(1);
    if (circular[index0]||(circular[index1]&&kinkl->GetDistance()>0.2)) continue;
    kinkl->SetMultiple(usage[index0],0);
    kinkl->SetMultiple(usage[index1],1);
    if (kinkl->GetMultiple()[0]+kinkl->GetMultiple()[1]>2) continue;
    if (kinkl->GetMultiple()[0]+kinkl->GetMultiple()[1]>0 && quality[indexes[i]]>0.2) continue;
    if (kinkl->GetMultiple()[0]+kinkl->GetMultiple()[1]>0 && kinkl->GetDistance()>0.2) continue;
    if (circular[index0]||(circular[index1]&&kinkl->GetDistance()>0.1)) continue;

    AliTPCseed * ktrack0 = (AliTPCseed*)array->At(index0);
    AliTPCseed * ktrack1 = (AliTPCseed*)array->At(index1);
    if (!ktrack0 || !ktrack1) continue;
    Int_t index = esd->AddKink(kinkl);
    //
    //
    if ( ktrack0->GetKinkIndex(0)==0 && ktrack1->GetKinkIndex(0)==0) {  //best kink
      if (mothers[indexes[i]]->GetNumberOfClusters()>20 && daughters[indexes[i]]->GetNumberOfClusters()>20 && 
	  (mothers[indexes[i]]->GetNumberOfClusters()+daughters[indexes[i]]->GetNumberOfClusters())>100){
	*ktrack0 = *mothers[indexes[i]];
	*ktrack1 = *daughters[indexes[i]];
      }
    }
    //
    ktrack0->SetKinkIndex(usage[index0],-(index+1));
    ktrack1->SetKinkIndex(usage[index1], (index+1));
    usage[index0]++;
    usage[index1]++;
  }
  //
  // Remove tracks corresponding to shared kink's
  //
  for (Int_t i=0;i<nentries;i++){
    AliTPCseed * track0 = (AliTPCseed*)array->At(i);
    if (!track0) continue;
    if (track0->GetKinkIndex(0)!=0) continue;
    if (shared[i]) MarkSeedFree( array->RemoveAt(i) );
  }

  //
  //
  RemoveUsed2(array,0.5,0.4,30);
  UnsignClusters();
  for (Int_t i=0;i<nentries;i++){
    AliTPCseed * track0 = (AliTPCseed*)array->At(i);
    if (!track0) continue;
    track0->CookdEdx(0.02,0.6);
    track0->CookPID();
  }
  //
  for (Int_t i=0;i<nentries;i++){
    AliTPCseed * track0 = (AliTPCseed*)array->At(i);
    if (!track0) continue;
    if (track0->Pt()<1.4) continue;
    //remove double high momenta tracks - overlapped with kink candidates
    Int_t ishared=0;
    Int_t all   =0;
    for (Int_t icl=track0->GetFirstPoint();icl<track0->GetLastPoint(); icl++){
      if (track0->GetClusterPointer(icl)!=0){
	all++;
	if (track0->GetClusterPointer(icl)->IsUsed(10)) ishared++;
      }
    }
    if (Float_t(ishared+1)/Float_t(all+1)>0.5) {  
      MarkSeedFree( array->RemoveAt(i) );
      continue;
    }
    //
    if (track0->GetKinkIndex(0)!=0) continue;
    if (track0->GetNumberOfClusters()<80) continue;

    AliTPCseed *pmother = new( NextFreeSeed() ) AliTPCseed();
    pmother->SetPoolID(fLastSeedID);
    AliTPCseed *pdaughter = new( NextFreeSeed() ) AliTPCseed();
    pdaughter->SetPoolID(fLastSeedID);
    AliKink *pkink = new AliKink;

    AliTPCseed & mother = *pmother;
    AliTPCseed & daughter = *pdaughter;
    AliKink & kinkl = *pkink;
    if (CheckKinkPoint(track0,mother,daughter, kinkl)){
      if (mother.GetNumberOfClusters()<30||daughter.GetNumberOfClusters()<20) {
	MarkSeedFree( pmother );
	MarkSeedFree( pdaughter );
	delete pkink;
	continue;  //too short tracks
      }
      if (mother.Pt()<1.4) {
	MarkSeedFree( pmother );
	MarkSeedFree( pdaughter );
	delete pkink;
	continue;
      }
      Int_t row0= kinkl.GetTPCRow0();
      if (kinkl.GetDistance()>0.5 || kinkl.GetR()<110. || kinkl.GetR()>240.) {
	MarkSeedFree( pmother );
	MarkSeedFree( pdaughter );
	delete pkink;
	continue;
      }
      //
      Int_t index = esd->AddKink(&kinkl);      
      mother.SetKinkIndex(0,-(index+1));
      daughter.SetKinkIndex(0,index+1);
      if (mother.GetNumberOfClusters()>50) {
	MarkSeedFree( array->RemoveAt(i) );
	AliTPCseed* mtc = new( NextFreeSeed() ) AliTPCseed(mother);
	mtc->SetPoolID(fLastSeedID);
	array->AddAt(mtc,i);
      }
      else{
	AliTPCseed* mtc = new( NextFreeSeed() ) AliTPCseed(mother);
	mtc->SetPoolID(fLastSeedID);
	array->AddLast(mtc);
      }
      AliTPCseed* dtc = new( NextFreeSeed() ) AliTPCseed(daughter);
      dtc->SetPoolID(fLastSeedID);
      array->AddLast(dtc);
      for (Int_t icl=0;icl<row0;icl++) {
	if (mother.GetClusterPointer(icl)) mother.GetClusterPointer(icl)->Use(20);
      }
      //
      for (Int_t icl=row0;icl<158;icl++) {
	if (daughter.GetClusterPointer(icl)) daughter.GetClusterPointer(icl)->Use(20);
      }
      //
    }
    MarkSeedFree( pmother );
    MarkSeedFree( pdaughter );
    delete pkink;
  }

  delete [] daughters;
  delete [] mothers;
  //
  //
  delete [] dca;
  delete []circular;
  delete []shared;
  delete []quality;
  delete []indexes;
  //
  delete kink;
  delete[]fim;
  delete[] zm;
  delete[] z0;
  delete [] usage;
  delete[] alpha;
  delete[] nclusters;
  delete[] sign;
  delete[] helixes;
  kinks->Delete();
  delete kinks;

  AliInfo(Form("Ncandidates=\t%d\t%d\t%d\t%d\n",esd->GetNumberOfKinks(),ncandidates,ntracks,nall));
  timer.Print();
}
*/

Int_t AliTPCtracker::RefitKink(AliTPCseed &mother, AliTPCseed &daughter, const AliESDkink &knk)
{
  //
  // refit kink towards to the vertex
  //
  //
  AliKink &kink=(AliKink &)knk;

  Int_t row0 = GetRowNumber(kink.GetR());
  FollowProlongation(mother,0);
  mother.Reset(kFALSE);
  //
  FollowProlongation(daughter,row0);
  daughter.Reset(kFALSE);
  FollowBackProlongation(daughter,158);
  daughter.Reset(kFALSE);
  Int_t first = TMath::Max(row0-20,30); 
  Int_t last  = TMath::Min(row0+20,140);
  //
  const Int_t kNdiv =5;
  AliTPCseed  param0[kNdiv];  // parameters along the track
  AliTPCseed  param1[kNdiv];  // parameters along the track
  AliKink     kinks[kNdiv];   // corresponding kink parameters
  //
  Int_t rows[kNdiv];
  for (Int_t irow=0; irow<kNdiv;irow++){
    rows[irow] = first +((last-first)*irow)/(kNdiv-1);
  }
  // store parameters along the track
  //
  for (Int_t irow=0;irow<kNdiv;irow++){
    FollowBackProlongation(mother, rows[irow]);
    FollowProlongation(daughter,rows[kNdiv-1-irow]);       
    param0[irow] = mother;
    param1[kNdiv-1-irow] = daughter;
  }
  //
  // define kinks 
  for (Int_t irow=0; irow<kNdiv-1;irow++){
    if (param0[irow].GetNumberOfClusters()<kNdiv||param1[irow].GetNumberOfClusters()<kNdiv) continue;
    kinks[irow].SetMother(param0[irow]);
    kinks[irow].SetDaughter(param1[irow]);
    kinks[irow].Update();
  }
  //
  // choose kink with best "quality"
  Int_t index =-1;
  Double_t mindist = 10000;
  for (Int_t irow=0;irow<kNdiv;irow++){
    if (param0[irow].GetNumberOfClusters()<20||param1[irow].GetNumberOfClusters()<20) continue;
    if (TMath::Abs(kinks[irow].GetR())>240.) continue;
    if (TMath::Abs(kinks[irow].GetR())<100.) continue;
    //
    Float_t normdist = TMath::Abs(param0[irow].GetX()-kinks[irow].GetR())*(0.1+kink.GetDistance());
    normdist/= (param0[irow].GetNumberOfClusters()+param1[irow].GetNumberOfClusters()+40.);
    if (normdist < mindist){
      mindist = normdist;
      index = irow;
    }
  }
  //
  if (index==-1) return 0;
  //
  //
  param0[index].Reset(kTRUE);
  FollowProlongation(param0[index],0);
  //
  mother = param0[index];
  daughter = param1[index];  // daughter in vertex
  //
  kink.SetMother(mother);
  kink.SetDaughter(daughter);
  kink.Update();
  kink.SetTPCRow0(GetRowNumber(kink.GetR()));
  kink.SetTPCncls(param0[index].GetNumberOfClusters(),0);
  kink.SetTPCncls(param1[index].GetNumberOfClusters(),1);
  kink.SetLabel(CookLabel(&mother,0.4, 0,kink.GetTPCRow0()),0);
  kink.SetLabel(CookLabel(&daughter,0.4, kink.GetTPCRow0(),160),1);
  mother.SetLabel(kink.GetLabel(0));
  daughter.SetLabel(kink.GetLabel(1));

  return 1;
}


void AliTPCtracker::UpdateKinkQualityM(AliTPCseed * seed){
  //
  // update Kink quality information for mother after back propagation
  //
  if (seed->GetKinkIndex(0)>=0) return; 
  for (Int_t ikink=0;ikink<3;ikink++){
    Int_t index = seed->GetKinkIndex(ikink);
    if (index>=0) break;
    index = TMath::Abs(index)-1;
    AliESDkink * kink = fEvent->GetKink(index);
    kink->SetTPCDensity(-1,0,0);
    kink->SetTPCDensity(1,0,1);
    //
    Int_t row0 = kink->GetTPCRow0() - 2 - Int_t( 0.5/ (0.05+kink->GetAngle(2)));
    if (row0<15) row0=15;
    //
    Int_t row1 = kink->GetTPCRow0() + 2 +  Int_t( 0.5/ (0.05+kink->GetAngle(2)));
    if (row1>145) row1=145;
    //
    Int_t found,foundable,shared;
    seed->GetClusterStatistic(0,row0, found, foundable,shared,kFALSE);
    if (foundable>5)   kink->SetTPCDensity(Float_t(found)/Float_t(foundable),0,0);
    seed->GetClusterStatistic(row1,155, found, foundable,shared,kFALSE);
    if (foundable>5)   kink->SetTPCDensity(Float_t(found)/Float_t(foundable),0,1);
  }
    
}

void AliTPCtracker::UpdateKinkQualityD(AliTPCseed * seed){
  //
  // update Kink quality information for daughter after refit
  //
  if (seed->GetKinkIndex(0)<=0) return; 
  for (Int_t ikink=0;ikink<3;ikink++){
    Int_t index = seed->GetKinkIndex(ikink);
    if (index<=0) break;
    index = TMath::Abs(index)-1;
    AliESDkink * kink = fEvent->GetKink(index);
    kink->SetTPCDensity(-1,1,0);
    kink->SetTPCDensity(-1,1,1);
    //
    Int_t row0 = kink->GetTPCRow0() -2 - Int_t( 0.5/ (0.05+kink->GetAngle(2)));
    if (row0<15) row0=15;
    //
    Int_t row1 = kink->GetTPCRow0() +2 +  Int_t( 0.5/ (0.05+kink->GetAngle(2)));
    if (row1>145) row1=145;
    //
    Int_t found,foundable,shared;
    seed->GetClusterStatistic(0,row0, found, foundable,shared,kFALSE);
    if (foundable>5)   kink->SetTPCDensity(Float_t(found)/Float_t(foundable),1,0);
    seed->GetClusterStatistic(row1,155, found, foundable,shared,kFALSE);
    if (foundable>5)   kink->SetTPCDensity(Float_t(found)/Float_t(foundable),1,1);
  }
    
}


Int_t  AliTPCtracker::CheckKinkPoint(AliTPCseed*seed,AliTPCseed &mother, AliTPCseed &daughter, const AliESDkink &knk)
{
  //
  // check kink point for given track
  // if return value=0 kink point not found
  // otherwise seed0 correspond to mother particle
  //           seed1 correspond to daughter particle
  //           kink  parameter of kink point
  AliKink &kink=(AliKink &)knk;

  Int_t middlerow = (seed->GetFirstPoint()+seed->GetLastPoint())/2;
  Int_t first = seed->GetFirstPoint(); 
  Int_t last  = seed->GetLastPoint();
  if (last-first<20) return 0;          // shortest length - 2*30 = 60 pad-rows

  
  AliTPCseed *seed1 = ReSeed(seed,middlerow+20, kTRUE);  //middle of chamber
  if (!seed1) return 0;
  FollowProlongation(*seed1,seed->GetLastPoint()-20);
  seed1->Reset(kTRUE);
  FollowProlongation(*seed1,158);
  seed1->Reset(kTRUE);  
  last = seed1->GetLastPoint();
  //
  AliTPCseed *seed0 = new( NextFreeSeed() ) AliTPCseed(*seed);
  seed0->SetPoolID(fLastSeedID);
  seed0->Reset(kFALSE);
  seed0->Reset();
  //
  AliTPCseed  param0[20];  // parameters along the track
  AliTPCseed  param1[20];  // parameters along the track
  AliKink     kinks[20];   // corresponding kink parameters
  Int_t rows[20];
  for (Int_t irow=0; irow<20;irow++){
    rows[irow] = first +((last-first)*irow)/19;
  }
  // store parameters along the track
  //
  for (Int_t irow=0;irow<20;irow++){
    FollowBackProlongation(*seed0, rows[irow]);
    FollowProlongation(*seed1,rows[19-irow]);       
    param0[irow] = *seed0;
    param1[19-irow] = *seed1;
  }
  //
  // define kinks 
  for (Int_t irow=0; irow<19;irow++){
    kinks[irow].SetMother(param0[irow]);
    kinks[irow].SetDaughter(param1[irow]);
    kinks[irow].Update();
  }
  //
  // choose kink with biggest change of angle
  Int_t index =-1;
  Double_t maxchange= 0;
  for (Int_t irow=1;irow<19;irow++){
    if (TMath::Abs(kinks[irow].GetR())>240.) continue;
    if (TMath::Abs(kinks[irow].GetR())<110.) continue;
    Float_t quality = TMath::Abs(kinks[irow].GetAngle(2))/(3.+TMath::Abs(kinks[irow].GetR()-param0[irow].GetX()));
    if ( quality > maxchange){
      maxchange = quality;
      index = irow;
      //
    }
  }
  MarkSeedFree( seed0 );
  MarkSeedFree( seed1 );
  if (index<0) return 0;
  //
  Int_t row0    = GetRowNumber(kinks[index].GetR());   //row 0 estimate
  seed0 = new( NextFreeSeed() ) AliTPCseed(param0[index]);
  seed0->SetPoolID(fLastSeedID);
  seed1 = new( NextFreeSeed() ) AliTPCseed(param1[index]);
  seed1->SetPoolID(fLastSeedID);
  seed0->Reset(kFALSE);
  seed1->Reset(kFALSE);
  seed0->ResetCovariance(10.);
  seed1->ResetCovariance(10.);
  FollowProlongation(*seed0,0);
  FollowBackProlongation(*seed1,158);
  mother = *seed0; // backup mother at position 0
  seed0->Reset(kFALSE);  
  seed1->Reset(kFALSE);
  seed0->ResetCovariance(10.);
  seed1->ResetCovariance(10.);
  //
  first = TMath::Max(row0-20,0);
  last  = TMath::Min(row0+20,158);
  //
  for (Int_t irow=0; irow<20;irow++){
    rows[irow] = first +((last-first)*irow)/19;
  }
  // store parameters along the track
  //
  for (Int_t irow=0;irow<20;irow++){
    FollowBackProlongation(*seed0, rows[irow]);
    FollowProlongation(*seed1,rows[19-irow]);       
    param0[irow] = *seed0;
    param1[19-irow] = *seed1;
  }
  //
  // define kinks 
  for (Int_t irow=0; irow<19;irow++){
    kinks[irow].SetMother(param0[irow]);
    kinks[irow].SetDaughter(param1[irow]);
    //    param0[irow].Dump();
    //param1[irow].Dump();
    kinks[irow].Update();
  }
  //
  // choose kink with biggest change of angle
  index =-1;
  maxchange= 0;
  for (Int_t irow=0;irow<20;irow++){
    if (TMath::Abs(kinks[irow].GetR())>250.) continue;
    if (TMath::Abs(kinks[irow].GetR())<90.) continue;
    Float_t quality = TMath::Abs(kinks[irow].GetAngle(2))/(3.+TMath::Abs(kinks[irow].GetR()-param0[irow].GetX()));
    if ( quality > maxchange){
      maxchange = quality;
      index = irow;
      //
    }
  }
  //
  //
  if (index==-1 || param0[index].GetNumberOfClusters()+param1[index].GetNumberOfClusters()<100){
    MarkSeedFree( seed0 );
    MarkSeedFree( seed1 );
    return 0;
  }

  //  Float_t anglesigma = TMath::Sqrt(param0[index].fC22+param0[index].fC33+param1[index].fC22+param1[index].fC33);
  
  kink.SetMother(param0[index]);
  kink.SetDaughter(param1[index]);
  kink.Update();

  Double_t chi2P2 = param0[index].GetParameter()[2]-param1[index].GetParameter()[2];
  chi2P2*=chi2P2;
  chi2P2/=param0[index].GetCovariance()[5]+param1[index].GetCovariance()[5];
  Double_t chi2P3 = param0[index].GetParameter()[3]-param1[index].GetParameter()[3];
  chi2P3*=chi2P3;
  chi2P3/=param0[index].GetCovariance()[9]+param1[index].GetCovariance()[9];
  //
  if (AliTPCReconstructor::StreamLevel()&kStreamFindKinks) { // flag: stream track infroamtion in the FindKinks method
    (*fDebugStreamer)<<"kinkHpt"<<
      "chi2P2="<<chi2P2<<
      "chi2P3="<<chi2P3<<
      "p0.="<<&param0[index]<<
      "p1.="<<&param1[index]<<
      "k.="<<&kink<<
      "\n";
  }
  if ( chi2P2+chi2P3<AliTPCReconstructor::GetRecoParam()->GetKinkAngleCutChi2(0)){
    MarkSeedFree( seed0 );
    MarkSeedFree( seed1 );
    return 0; 
  }


  row0    = GetRowNumber(kink.GetR());   
  kink.SetTPCRow0(row0);
  kink.SetLabel(CookLabel(seed0,0.5,0,row0),0);
  kink.SetLabel(CookLabel(seed1,0.5,row0,158),1);
  kink.SetIndex(-10,0);
  kink.SetIndex(int(param0[index].GetNumberOfClusters()+param1[index].GetNumberOfClusters()),1);
  kink.SetTPCncls(param0[index].GetNumberOfClusters(),0);
  kink.SetTPCncls(param1[index].GetNumberOfClusters(),1);
  //
  //
  //  new (&mother) AliTPCseed(param0[index]);
  daughter = param1[index];
  daughter.SetLabel(kink.GetLabel(1));  
  param0[index].Reset(kTRUE);
  FollowProlongation(param0[index],0);    
  mother = param0[index];
  mother.SetLabel(kink.GetLabel(0));
  if ( chi2P2+chi2P3<AliTPCReconstructor::GetRecoParam()->GetKinkAngleCutChi2(1)){
    mother=*seed;
  }
  MarkSeedFree( seed0 );
  MarkSeedFree( seed1 );
  //
  return 1;
}




AliTPCseed*  AliTPCtracker::ReSeed(AliTPCseed *t)
{
  //
  // reseed - refit -  track
  //
  Int_t first = 0;
  //  Int_t last  = fSectors->GetNRows()-1;
  //
  if (fSectors == fOuterSec){
    first = TMath::Max(first, t->GetFirstPoint()-fInnerSec->GetNRows());
    //last  = 
  }
  else
    first = t->GetFirstPoint();
  //
  AliTPCseed * seed = MakeSeed(t,0.1,0.5,0.9);
  FollowBackProlongation(*t,fSectors->GetNRows()-1);
  t->Reset(kFALSE);
  FollowProlongation(*t,first);
  return seed;
}







//_____________________________________________________________________________
Int_t AliTPCtracker::ReadSeeds(const TFile *inp) {
  //-----------------------------------------------------------------
  // This function reades track seeds.
  //-----------------------------------------------------------------
  TDirectory *savedir=gDirectory; 

  TFile *in=(TFile*)inp;
  if (!in->IsOpen()) {
     cerr<<"AliTPCtracker::ReadSeeds(): input file is not open !\n";
     return 1;
  }

  in->cd();
  TTree *seedTree=(TTree*)in->Get("Seeds");
  if (!seedTree) {
     cerr<<"AliTPCtracker::ReadSeeds(): ";
     cerr<<"can't get a tree with track seeds !\n";
     return 2;
  }
  AliTPCtrack *seed=new AliTPCtrack; 
  seedTree->SetBranchAddress("tracks",&seed);
  
  if (fSeeds==0) fSeeds=new TObjArray(15000);

  Int_t n=(Int_t)seedTree->GetEntries();
  for (Int_t i=0; i<n; i++) {
     seedTree->GetEvent(i);
     AliTPCseed* sdc = new( NextFreeSeed() ) AliTPCseed(*seed/*,seed->GetAlpha()*/);
     sdc->SetPoolID(fLastSeedID);
     fSeeds->AddLast(sdc);
  }
  
  delete seed; // RS: this seed is not from the pool, delete it !!!
  delete seedTree; 
  savedir->cd();
  return 0;
}

Int_t AliTPCtracker::Clusters2TracksHLT (AliESDEvent *const esd, const AliESDEvent *hltEvent)
{
  //
  // clusters to tracks
  if (fSeeds) DeleteSeeds();
  else ResetSeedsPool();
  fEvent = esd; 
  fEventHLT = hltEvent;
  if (AliTPCReconstructor::GetRecoParam()->GetUseOulierClusterFilter()) FilterOutlierClusters();  
  AliTPCTransform *transform = AliTPCcalibDB::Instance()->GetTransform() ;  
  transform->SetCurrentTimeStamp( esd->GetTimeStamp());
  transform->SetCurrentRun(esd->GetRunNumber());

  
  Clusters2Tracks();
  fEventHLT = 0;
  if (!fSeeds) return 1;
  FillESD(fSeeds);
  if ((AliTPCReconstructor::StreamLevel()&kStreamClDump)>0)  DumpClusters(0,fSeeds);
  return 0;
  //
}

Int_t AliTPCtracker::Clusters2Tracks(AliESDEvent *const esd)
{
  //
  // clusters to tracks
  return Clusters2TracksHLT( esd, 0);
}

//_____________________________________________________________________________
Int_t AliTPCtracker::Clusters2Tracks() {
  //-----------------------------------------------------------------
  // This is a track finder.
  //-----------------------------------------------------------------
  TDirectory *savedir=gDirectory; 
  TStopwatch timer;

  fIteration = 0;
  fSeeds = Tracking();

  if (fDebug>0){
    Info("Clusters2Tracks","Time for tracking: \t");timer.Print();timer.Start();
  }
  //activate again some tracks
  for (Int_t i=0; i<fSeeds->GetEntriesFast(); i++) {
    AliTPCseed *pt=(AliTPCseed*)fSeeds->UncheckedAt(i), &t=*pt;    
    if (!pt) continue;    
    Int_t nc=t.GetNumberOfClusters();
    if (nc<20) {
      MarkSeedFree( fSeeds->RemoveAt(i) );
      continue;
    } 
    CookLabel(pt,0.1);
    if (pt->GetRemoval()==10) {
      if (pt->GetDensityFirst(20)>0.8 || pt->GetDensityFirst(30)>0.8 || pt->GetDensityFirst(40)>0.7)
	pt->Desactivate(10);  // make track again active  // MvL: should be 0 ?
      else{
	pt->Desactivate(20); 	
	MarkSeedFree( fSeeds->RemoveAt(i) );
      }
    } 
  }
  //
  RemoveUsed2(fSeeds,0.85,0.85,0);
  if (AliTPCReconstructor::GetRecoParam()->GetDoKinks()) FindKinks(fSeeds,fEvent);
  //FindCurling(fSeeds, fEvent,0);  
  if (AliTPCReconstructor::StreamLevel()&kStreamFindMultiMC)  FindMultiMC(fSeeds, fEvent,-1); // find multi found tracks
  RemoveUsed2(fSeeds,0.5,0.4,20);
  FindSplitted(fSeeds, fEvent,0); // find multi found tracks
  if (AliTPCReconstructor::StreamLevel()&kStreamFindMultiMC)  FindMultiMC(fSeeds, fEvent,0); // find multi found tracks

 //  //
//   // refit short tracks
//   //
  Int_t nseed=fSeeds->GetEntriesFast();
  //
  Int_t found = 0;
  for (Int_t i=0; i<nseed; i++) {
    AliTPCseed *pt=(AliTPCseed*)fSeeds->UncheckedAt(i), &t=*pt;    
    if (!pt) continue;    
    Int_t nc=t.GetNumberOfClusters();
    if (nc<15) {
      MarkSeedFree( fSeeds->RemoveAt(i) );
      continue;
    }
    CookLabel(pt,0.1); //For comparison only
    //if ((pt->IsActive() || (pt->fRemoval==10) )&& nc>50 &&pt->GetNumberOfClusters()>0.4*pt->fNFoundable){
    if ((pt->IsActive() || (pt->GetRemoval()==10) )){
      found++;      
      if (fDebug>0) cerr<<found<<'\r';      
      pt->SetLab2(i);
    }
    else
      MarkSeedFree( fSeeds->RemoveAt(i) );
  }

  
  //RemoveOverlap(fSeeds,0.99,7,kTRUE);  
  SignShared(fSeeds);  
  //RemoveUsed(fSeeds,0.9,0.9,6);
  // 
  nseed=fSeeds->GetEntriesFast();
  found = 0;
  for (Int_t i=0; i<nseed; i++) {
    AliTPCseed *pt=(AliTPCseed*)fSeeds->UncheckedAt(i), &t=*pt;    
    if (!pt) continue;    
    Int_t nc=t.GetNumberOfClusters();
    if (nc<15) {
      MarkSeedFree( fSeeds->RemoveAt(i) );
      continue;
    }
    t.SetUniqueID(i);
    t.CookdEdx(0.02,0.6);
    //    CheckKinkPoint(&t,0.05);
    //if ((pt->IsActive() || (pt->fRemoval==10) )&& nc>50 &&pt->GetNumberOfClusters()>0.4*pt->fNFoundable){
    if ((pt->IsActive() || (pt->GetRemoval()==10) )){
      found++;
      if (fDebug>0){
	cerr<<found<<'\r';      
      }
      pt->SetLab2(i);
    }
    else
      MarkSeedFree( fSeeds->RemoveAt(i) );
    //AliTPCseed * seed1 = ReSeed(pt,0.05,0.5,1);
    //if (seed1){
    //  FollowProlongation(*seed1,0);
    //  Int_t n = seed1->GetNumberOfClusters();
    //  printf("fP4\t%f\t%f\n",seed1->GetC(),pt->GetC());
    //  printf("fN\t%d\t%d\n", seed1->GetNumberOfClusters(),pt->GetNumberOfClusters());
    //
    //}
    //AliTPCseed * seed2 = ReSeed(pt,0.95,0.5,0.05);
    
  }

  SortTracks(fSeeds, 1);
  
  /*    
  fIteration = 1;
  PrepareForBackProlongation(fSeeds,5.);
  PropagateBack(fSeeds);
  printf("Time for back propagation: \t");timer.Print();timer.Start();
  
  fIteration = 2;
  
  PrepareForProlongation(fSeeds,5.);
  PropagateForard2(fSeeds);
   
  printf("Time for FORWARD propagation: \t");timer.Print();timer.Start();
  // RemoveUsed(fSeeds,0.7,0.7,6);
  //RemoveOverlap(fSeeds,0.9,7,kTRUE);
   
  nseed=fSeeds->GetEntriesFast();
  found = 0;
  for (Int_t i=0; i<nseed; i++) {
    AliTPCseed *pt=(AliTPCseed*)fSeeds->UncheckedAt(i), &t=*pt;    
    if (!pt) continue;    
    Int_t nc=t.GetNumberOfClusters();
    if (nc<15) {
      MarkSeedFree( fSeeds->RemoveAt(i) );
      continue;
    }
    t.CookdEdx(0.02,0.6);
    //    CookLabel(pt,0.1); //For comparison only
    //if ((pt->IsActive() || (pt->fRemoval==10) )&& nc>50 &&pt->GetNumberOfClusters()>0.4*pt->fNFoundable){
    if ((pt->IsActive() || (pt->fRemoval==10) )){
      cerr<<found++<<'\r';      
    }
    else
      MarkSeedFree( fSeeds->RemoveAt(i) );
    pt->fLab2 = i;
  }
  */
 
  //  fNTracks = found;
  if (fDebug>0){
    Info("Clusters2Tracks","Time for overlap removal, track writing and dedx cooking: \t"); timer.Print();timer.Start();
  }
  //
  //  cerr<<"Number of found tracks : "<<"\t"<<found<<endl;  
  Info("Clusters2Tracks","Number of found tracks %d",found);  
  savedir->cd();
  //  UnloadClusters();
  //  
  return 0;
}

void AliTPCtracker::Tracking(TObjArray * arr)
{
  //
  // tracking of the seeds
  //

  fSectors = fOuterSec;
  ParallelTracking(arr,150,63);
  fSectors = fOuterSec;
  ParallelTracking(arr,63,0);
}

TObjArray * AliTPCtracker::Tracking(Int_t seedtype, Int_t i1, Int_t i2, Float_t cuts[4], Float_t dy, Int_t dsec)
{
  //
  //
  //tracking routine
  static TObjArray arrTracks;
  TObjArray * arr = &arrTracks;
  // 
  fSectors = fOuterSec;
  TStopwatch timer;
  timer.Start();
  for (Int_t sec=0;sec<fkNOS;sec++){
    if (seedtype==3) MakeSeeds3(arr,sec,i1,i2,cuts,dy, dsec);
    if (seedtype==4) MakeSeeds5(arr,sec,i1,i2,cuts,dy);    
    if (seedtype==2) MakeSeeds2(arr,sec,i1,i2,cuts,dy);
  }
  if (fDebug>0){
    Info("Tracking","\nSeeding - %d\t%d\t%d\t%d\n",seedtype,i1,i2,arr->GetEntriesFast());
    timer.Print();
    timer.Start();
  }
  Tracking(arr);  
  if (fDebug>0){
    timer.Print();
  }

  return arr;
}

TObjArray * AliTPCtracker::Tracking()
{
  // tracking
  //
  if (AliTPCReconstructor::GetRecoParam()->GetSpecialSeeding()) return TrackingSpecial();
  TStopwatch timer;
  timer.Start();
  Int_t nup=fOuterSec->GetNRows()+fInnerSec->GetNRows();

  TObjArray * seeds = new TObjArray;
  TObjArray * arr=0;
  Int_t fLastSeedRowSec=AliTPCReconstructor::GetRecoParam()->GetLastSeedRowSec();
  Int_t gapPrim = AliTPCReconstructor::GetRecoParam()->GetSeedGapPrim();
  Int_t gapSec = AliTPCReconstructor::GetRecoParam()->GetSeedGapSec();
  
  Int_t gap =20;
  Float_t cuts[4];
  cuts[0] = 0.002;
  cuts[1] = 1.5;
  cuts[2] = 3.;
  cuts[3] = 3.;
  Float_t fnumber  = 3.0;
  Float_t fdensity = 3.0;

  // make HLT seeds
  if (AliTPCReconstructor::GetRecoParam()->GetUseHLTPreSeeding()) {
    arr = MakeSeedsHLT( fEventHLT );
    if( arr ){
      SumTracks(seeds,arr);     
      delete arr;
      arr=0;
      //cout<<"HLT tracks left after sorting: "<<seeds->GetEntriesFast()<<endl;
      //SignClusters(seeds,fnumber,fdensity);    
    }
  }
  
  //  
  //find primaries  
  cuts[0]=0.0066;
  for (Int_t delta = 0; delta<18; delta+=gapPrim){
    //
    cuts[0]=0.0070;
    cuts[1] = 1.5;
    arr = Tracking(3,nup-1-delta,nup-1-delta-gap,cuts,-1,1);
    SumTracks(seeds,arr);   
    SignClusters(seeds,fnumber,fdensity); 
    //
    for (Int_t i=2;i<6;i+=2){
      // seed high pt tracks
      cuts[0]=0.0022;
      cuts[1]=0.3;
      arr = Tracking(3,nup-i-delta,nup-i-delta-gap,cuts,-1,0);
      SumTracks(seeds,arr);   
      SignClusters(seeds,fnumber,fdensity);        
    }
  }
  fnumber  = 4;
  fdensity = 4.;
  //  RemoveUsed(seeds,0.9,0.9,1);
  //  UnsignClusters();
  //  SignClusters(seeds,fnumber,fdensity);    

  //find primaries  
  cuts[0]=0.0077;
  for (Int_t delta = 20; delta<120; delta+=gapPrim){
    //
    // seed high pt tracks
    cuts[0]=0.0060;
    cuts[1]=0.3;
    cuts[2]=6.;
    arr = Tracking(3,nup-delta,nup-delta-gap,cuts,-1);
    SumTracks(seeds,arr);   
    SignClusters(seeds,fnumber,fdensity);            

    cuts[0]=0.003;
    cuts[1]=0.3;
    cuts[2]=6.;
    arr = Tracking(3,nup-delta-5,nup-delta-5-gap,cuts,-1);
    SumTracks(seeds,arr);   
    SignClusters(seeds,fnumber,fdensity);            
  }

  cuts[0] = 0.01;
  cuts[1] = 2.0;
  cuts[2] = 3.;
  cuts[3] = 2.0;
  fnumber  = 2.;
  fdensity = 2.;
  
  if (fDebug>0){
    Info("Tracking()","\n\nPrimary seeding\t%d\n\n",seeds->GetEntriesFast());
    timer.Print();
    timer.Start();
  }
  //  RemoveUsed(seeds,0.75,0.75,1);
  //UnsignClusters();
  //SignClusters(seeds,fnumber,fdensity);
  
  // find secondaries

  cuts[0] = 0.3;
  cuts[1] = 1.5;
  cuts[2] = 3.;
  cuts[3] = 1.5;

  arr = Tracking(4,nup-1,nup-1-gap,cuts,-1);
  SumTracks(seeds,arr);   
  SignClusters(seeds,fnumber,fdensity);   
  //
  arr = Tracking(4,nup-2,nup-2-gap,cuts,-1);
  SumTracks(seeds,arr);   
  SignClusters(seeds,fnumber,fdensity);   
  //
  arr = Tracking(4,nup-3,nup-3-gap,cuts,-1);
  SumTracks(seeds,arr);   
  SignClusters(seeds,fnumber,fdensity);   
  //
  arr = Tracking(4,nup-5,nup-5-gap,cuts,-1);
  SumTracks(seeds,arr);   
  SignClusters(seeds,fnumber,fdensity);   
  //
  arr = Tracking(4,nup-7,nup-7-gap,cuts,-1);
  SumTracks(seeds,arr);   
  SignClusters(seeds,fnumber,fdensity);   
  //
  //
  arr = Tracking(4,nup-9,nup-9-gap,cuts,-1);
  SumTracks(seeds,arr);   
  SignClusters(seeds,fnumber,fdensity);   
  //


  for (Int_t delta = 9; delta<30; delta+=gapSec){
    //
    cuts[0] = 0.3;
    cuts[1] = 1.5;
    cuts[2] = 3.;
    cuts[3] = 1.5;
    arr = Tracking(4,nup-1-delta,nup-1-delta-gap,cuts,-1);
    SumTracks(seeds,arr);   
    SignClusters(seeds,fnumber,fdensity);   
    //
    arr = Tracking(4,nup-3-delta,nup-5-delta-gap,cuts,4);
    SumTracks(seeds,arr);   
    SignClusters(seeds,fnumber,fdensity); 
    //
  } 
  fnumber  = 1;
  fdensity = 1;
  //
  // change cuts
  fnumber  = 2.;
  fdensity = 2.;
  cuts[0]=0.0080;


  // find secondaries
  for (Int_t delta = 30; delta<fLastSeedRowSec; delta+=gapSec){
    //
    cuts[0] = 0.3;
    cuts[1] = 3.5;
    cuts[2] = 3.;
    cuts[3] = 3.5;
    arr = Tracking(4,nup-1-delta,nup-1-delta-gap,cuts,-1);
    SumTracks(seeds,arr);   
    SignClusters(seeds,fnumber,fdensity);   
    //
    arr = Tracking(4,nup-5-delta,nup-5-delta-gap,cuts,5 );
    SumTracks(seeds,arr);   
    SignClusters(seeds,fnumber,fdensity);   
  }
 
  if (fDebug>0){
    Info("Tracking()","\n\nSecondary seeding\t%d\n\n",seeds->GetEntriesFast());
    timer.Print();
    timer.Start();
  }

  return seeds;
  //
      
}


TObjArray * AliTPCtracker::TrackingSpecial()
{
  //
  // seeding adjusted for laser and cosmic tests - short tracks with big inclination angle
  // no primary vertex seeding tried
  //
  TStopwatch timer;
  timer.Start();
  Int_t nup=fOuterSec->GetNRows()+fInnerSec->GetNRows();

  TObjArray * seeds = new TObjArray;
  TObjArray * arr=0;
  
  Int_t   gap  = 15;
  Float_t cuts[4];
  Float_t fnumber  = 3.0;
  Float_t fdensity = 3.0;
  
  // find secondaries
  cuts[0] = AliTPCReconstructor::GetRecoParam()->GetMaxC();   // max curvature
  cuts[1] = 3.5;    // max tan(phi) angle for seeding
  cuts[2] = 3.;     // not used (cut on z primary vertex)     
  cuts[3] = 3.5;    // max tan(theta) angle for seeding

  for (Int_t delta = 0; nup-delta-gap-1>0; delta+=3){
    //
    arr = Tracking(4,nup-1-delta,nup-1-delta-gap,cuts,-1);
    SumTracks(seeds,arr);   
    SignClusters(seeds,fnumber,fdensity);   
  } 
 
  if (fDebug>0){
    Info("Tracking()","\n\nSecondary seeding\t%d\n\n",seeds->GetEntriesFast());
    timer.Print();
    timer.Start();
  }

  return seeds;
  //
      
}


void AliTPCtracker::SumTracks(TObjArray *arr1,TObjArray *&arr2)
{
  //
  //sum tracks to common container
  //remove suspicious tracks
  // RS: Attention: supplied tracks come in the static array, don't delete them
  Int_t nseed = arr2->GetEntriesFast();
  for (Int_t i=0;i<nseed;i++){
    AliTPCseed *pt=(AliTPCseed*)arr2->UncheckedAt(i);    
    if (pt){
      //
      // remove tracks with too big curvature
      //
      if (TMath::Abs(pt->GetC())>AliTPCReconstructor::GetRecoParam()->GetMaxC()){
	MarkSeedFree( arr2->RemoveAt(i) );
	continue;
      }
       // REMOVE VERY SHORT  TRACKS
      if (pt->GetNumberOfClusters()<20){ 
	MarkSeedFree( arr2->RemoveAt(i) );
	continue;
      }// patch 28 fev06
      // NORMAL ACTIVE TRACK
      if (pt->IsActive()){
	arr1->AddLast(arr2->RemoveAt(i));
	continue;
      }
      //remove not usable tracks
      if (pt->GetRemoval()!=10){
	MarkSeedFree( arr2->RemoveAt(i) );
	continue;
      }
     
      // ENABLE ONLY ENOUGH GOOD STOPPED TRACKS
      if (pt->GetDensityFirst(20)>0.8 || pt->GetDensityFirst(30)>0.8 || pt->GetDensityFirst(40)>0.7)
	arr1->AddLast(arr2->RemoveAt(i));
      else{      
	MarkSeedFree( arr2->RemoveAt(i) );
      }
    }
  }
  // delete arr2;  arr2 = 0; // RS: this is static array, don't delete it
}



void  AliTPCtracker::ParallelTracking(TObjArray *const arr, Int_t rfirst, Int_t rlast)
{
  //
  // try to track in parralel

  Int_t nseed=arr->GetEntriesFast();
  //prepare seeds for tracking
  for (Int_t i=0; i<nseed; i++) {
    AliTPCseed *pt=(AliTPCseed*)arr->UncheckedAt(i), &t=*pt; 
    if (!pt) continue;
    if (!t.IsActive()) continue;
    // follow prolongation to the first layer
    if ( (fSectors ==fInnerSec) || (t.GetFirstPoint()-fkParam->GetNRowLow()>rfirst+1) )  
      FollowProlongation(t, rfirst+1);
  }


  //
  for (Int_t nr=rfirst; nr>=rlast; nr--){ 
    if (nr<fInnerSec->GetNRows()) 
      fSectors = fInnerSec;
    else
      fSectors = fOuterSec;
    // make indexes with the cluster tracks for given       

    // find nearest cluster
    for (Int_t i=0; i<nseed; i++) {
      AliTPCseed *pt=(AliTPCseed*)arr->UncheckedAt(i), &t=*pt;       
      if (!pt) continue;
      if (nr==80) pt->UpdateReference();
      if (!pt->IsActive()) continue;
      //      if ( (fSectors ==fOuterSec) && (pt->fFirstPoint-fkParam->GetNRowLow())<nr) continue;
      if (pt->GetRelativeSector()>17) {
	continue;
      }
      UpdateClusters(t,nr);
    }
    // prolonagate to the nearest cluster - if founded
    for (Int_t i=0; i<nseed; i++) {
      AliTPCseed *pt=(AliTPCseed*)arr->UncheckedAt(i); 
      if (!pt) continue;
      if (!pt->IsActive()) continue; 
      // if ((fSectors ==fOuterSec) && (pt->fFirstPoint-fkParam->GetNRowLow())<nr) continue;
      if (pt->GetRelativeSector()>17) {
	continue;
      }
      FollowToNextCluster(*pt,nr);
    }
  }    
}

void AliTPCtracker::PrepareForBackProlongation(const TObjArray *const arr,Float_t fac) const
{
  //
  //
  // if we use TPC track itself we have to "update" covariance
  //
  Int_t nseed= arr->GetEntriesFast();
  for (Int_t i=0;i<nseed;i++){
    AliTPCseed *pt = (AliTPCseed*)arr->UncheckedAt(i);
    if (pt) {
      pt->Modify(fac);
      //
      //rotate to current local system at first accepted  point    
      Int_t index  = pt->GetClusterIndex2(pt->GetFirstPoint()); 
      Int_t sec    = (index&0xff000000)>>24;
      sec = sec%18;
      Float_t angle1 = fInnerSec->GetAlpha()*sec+fInnerSec->GetAlphaShift();
      if (angle1>TMath::Pi()) 
	angle1-=2.*TMath::Pi();
      Float_t angle2 = pt->GetAlpha();
      
      if (TMath::Abs(angle1-angle2)>0.001){
	if (!pt->Rotate(angle1-angle2)) return;
	//angle2 = pt->GetAlpha();
	//pt->fRelativeSector = pt->GetAlpha()/fInnerSec->GetAlpha();
	//if (pt->GetAlpha()<0) 
	//  pt->fRelativeSector+=18;
	//sec = pt->fRelativeSector;
      }
	
    }
    
  }


}
void AliTPCtracker::PrepareForProlongation(TObjArray *const arr, Float_t fac) const
{
  //
  //
  // if we use TPC track itself we have to "update" covariance
  //
  Int_t nseed= arr->GetEntriesFast();
  for (Int_t i=0;i<nseed;i++){
    AliTPCseed *pt = (AliTPCseed*)arr->UncheckedAt(i);
    if (pt) {
      pt->Modify(fac);
      pt->SetFirstPoint(pt->GetLastPoint()); 
    }
    
  }


}

Int_t AliTPCtracker::PropagateBack(const TObjArray *const arr)
{
  //
  // make back propagation
  //
  Int_t nseed= arr->GetEntriesFast();
  for (Int_t i=0;i<nseed;i++){
    AliTPCseed *pt = (AliTPCseed*)arr->UncheckedAt(i);
    if (pt&& pt->GetKinkIndex(0)<=0) { 
      //AliTPCseed *pt2 = new AliTPCseed(*pt);
      fSectors = fInnerSec;
      //FollowBackProlongation(*pt,fInnerSec->GetNRows()-1);
      //fSectors = fOuterSec;
      FollowBackProlongation(*pt,fInnerSec->GetNRows()+fOuterSec->GetNRows()-1,1);     
      //if (pt->GetNumberOfClusters()<(pt->fEsd->GetTPCclusters(0)) ){
      //	Error("PropagateBack","Not prolonged track %d",pt->GetLabel());
      //	FollowBackProlongation(*pt2,fInnerSec->GetNRows()+fOuterSec->GetNRows()-1);
      //}
    }
    if (pt&& pt->GetKinkIndex(0)>0) {
      AliESDkink * kink = fEvent->GetKink(pt->GetKinkIndex(0)-1);
      pt->SetFirstPoint(kink->GetTPCRow0());
      fSectors = fInnerSec;
      FollowBackProlongation(*pt,fInnerSec->GetNRows()+fOuterSec->GetNRows()-1,1);  
    }
    CookLabel(pt,0.3);
  }
  return 0;
}


Int_t AliTPCtracker::PropagateForward2(const TObjArray *const arr)
{
  //
  // make forward propagation
  //
  Int_t nseed= arr->GetEntriesFast();
  //
  for (Int_t i=0;i<nseed;i++){
    AliTPCseed *pt = (AliTPCseed*)arr->UncheckedAt(i);
    if (pt) { 
      FollowProlongation(*pt,0,1,1);
      CookLabel(pt,0.3);
    }
    
  }
 return 0;
}


Int_t AliTPCtracker::PropagateForward()
{
  //
  // propagate track forward
  //UnsignClusters();
  Int_t nseed = fSeeds->GetEntriesFast();
  for (Int_t i=0;i<nseed;i++){
    AliTPCseed *pt = (AliTPCseed*)fSeeds->UncheckedAt(i);
    if (pt){
      AliTPCseed &t = *pt;
      Double_t alpha=t.GetAlpha() - fSectors->GetAlphaShift();
      if (alpha > 2.*TMath::Pi()) alpha -= 2.*TMath::Pi();  
      if (alpha < 0.            ) alpha += 2.*TMath::Pi();  
      t.SetRelativeSector(Int_t(alpha/fSectors->GetAlpha()+0.0001)%fN);
    }
  }
  
  fSectors = fOuterSec;
  ParallelTracking(fSeeds,fOuterSec->GetNRows()+fInnerSec->GetNRows()-1,fInnerSec->GetNRows());
  fSectors = fInnerSec;
  ParallelTracking(fSeeds,fInnerSec->GetNRows()-1,0);
  return 1;
}






Int_t AliTPCtracker::PropagateBack(AliTPCseed *const pt, Int_t row0, Int_t row1)
{
  //
  // make back propagation, in between row0 and row1
  //
  
  if (pt) { 
    fSectors = fInnerSec;
    Int_t  r1;
    //
    if (row1<fSectors->GetNRows()) 
      r1 = row1;
    else 
      r1 = fSectors->GetNRows()-1;

    if (row0<fSectors->GetNRows()&& r1>0 )
      FollowBackProlongation(*pt,r1);
    if (row1<=fSectors->GetNRows())
      return 0;
    //
    r1 = row1 - fSectors->GetNRows();
    if (r1<=0) return 0;
    if (r1>=fOuterSec->GetNRows()) return 0;
    fSectors = fOuterSec;
    return FollowBackProlongation(*pt,r1);
  }        
  return 0;
}




void  AliTPCtracker::GetShape(AliTPCseed * seed, Int_t row)
{
  // gets cluster shape
  // 
  AliTPCClusterParam * clparam = AliTPCcalibDB::Instance()->GetClusterParam();
  Float_t zdrift = TMath::Abs((fkParam->GetZLength(0)-TMath::Abs(seed->GetZ())));
  Int_t type = (seed->GetSector() < fkParam->GetNSector()/2) ? 0: (row>126) ? 1:2;
  Double_t angulary  = seed->GetSnp();

  if (TMath::Abs(angulary)>AliTPCReconstructor::GetMaxSnpTracker()) {
    angulary = TMath::Sign(AliTPCReconstructor::GetMaxSnpTracker(),angulary);
  }

  angulary = angulary*angulary/((1.-angulary)*(1.+angulary));
  Double_t angularz  = seed->GetTgl()*seed->GetTgl()*(1.+angulary);
  
  Double_t sigmay =  clparam->GetRMS0(0,type,zdrift,TMath::Sqrt(TMath::Abs(angulary)));
  Double_t sigmaz =  clparam->GetRMS0(1,type,zdrift,TMath::Sqrt(TMath::Abs(angularz)));
  seed->SetCurrentSigmaY2(sigmay*sigmay);
  seed->SetCurrentSigmaZ2(sigmaz*sigmaz);
  // Float_t sd2 = TMath::Abs((fkParam->GetZLength(0)-TMath::Abs(seed->GetZ())))*fkParam->GetDiffL()*fkParam->GetDiffL();
//   //  Float_t padlength =  fkParam->GetPadPitchLength(seed->fSector);
//   Float_t padlength =  GetPadPitchLength(row);
//   //
//   Float_t sresy = (seed->GetSector() < fkParam->GetNSector()/2) ? 0.2 :0.3;
//   seed->SetCurrentSigmaY2(sd2+padlength*padlength*angulary/12.+sresy*sresy);  
//   //
//   Float_t sresz = fkParam->GetZSigma();
//   seed->SetCurrentSigmaZ2(sd2+padlength*padlength*angularz*angularz*(1+angulary)/12.+sresz*sresz);
  /*
  Float_t wy = GetSigmaY(seed);
  Float_t wz = GetSigmaZ(seed);
  wy*=wy;
  wz*=wz;
  if (TMath::Abs(wy/seed->fCurrentSigmaY2-1)>0.0001 || TMath::Abs(wz/seed->fCurrentSigmaZ2-1)>0.0001 ){
    printf("problem\n");
  }
  */
}



//__________________________________________________________________________
void AliTPCtracker::CookLabel(AliKalmanTrack *tk, Float_t wrong) const {
  //--------------------------------------------------------------------
  //This function "cooks" a track label. If label<0, this track is fake.
  //--------------------------------------------------------------------
  AliTPCseed * t = dynamic_cast<AliTPCseed*>(tk);
  if(!t){
    printf("%s:%d wrong type \n",(char*)__FILE__,__LINE__);
    return;
  }

  Int_t noc=t->GetNumberOfClusters();
  if (noc<10){
    //printf("\nnot founded prolongation\n\n\n");
    //t->Dump();
    return ;
  }
  Int_t lb[160];
  Int_t mx[160];
  AliTPCclusterMI *clusters[160];
  //
  for (Int_t i=0;i<160;i++) {
    clusters[i]=0;
    lb[i]=mx[i]=0;
  }

  Int_t i;
  Int_t current=0;
  for (i=0; i<160 && current<noc; i++) {
     
     Int_t index=t->GetClusterIndex2(i);
     if (index<=0) continue; 
     if (index&0x8000) continue;
     //     
     //clusters[current]=GetClusterMI(index);
     if (t->GetClusterPointer(i)){
       clusters[current]=t->GetClusterPointer(i);     
       current++;
     }
  }
  noc = current;

  Int_t lab=123456789;
  for (i=0; i<noc; i++) {
    AliTPCclusterMI *c=clusters[i];
    if (!c) continue;
    lab=TMath::Abs(c->GetLabel(0));
    Int_t j;
    for (j=0; j<noc; j++) if (lb[j]==lab || mx[j]==0) break;
    lb[j]=lab;
    (mx[j])++;
  }

  Int_t max=0;
  for (i=0; i<noc; i++) if (mx[i]>max) {max=mx[i]; lab=lb[i];}
    
  for (i=0; i<noc; i++) {
    AliTPCclusterMI *c=clusters[i]; 
    if (!c) continue;
    if (TMath::Abs(c->GetLabel(1)) == lab ||
        TMath::Abs(c->GetLabel(2)) == lab ) max++;
  }
  if (noc<=0) { lab=-1; return;}
  if ((1.- Float_t(max)/(noc)) > wrong) lab=-lab;

  else {
     Int_t tail=Int_t(0.10*noc);
     max=0;
     Int_t ind=0;
     for (i=1; i<160&&ind<tail; i++) {
       //       AliTPCclusterMI *c=clusters[noc-i];
       AliTPCclusterMI *c=clusters[i];
       if (!c) continue;
       if (lab == TMath::Abs(c->GetLabel(0)) ||
           lab == TMath::Abs(c->GetLabel(1)) ||
           lab == TMath::Abs(c->GetLabel(2))) max++;
       ind++;
     }
     if (max < Int_t(0.5*tail)) lab=-lab;
  }

  t->SetLabel(lab);

  //  delete[] lb;
  //delete[] mx;
  //delete[] clusters;
}


//__________________________________________________________________________
Int_t AliTPCtracker::CookLabel(AliTPCseed *const t, Float_t wrong,Int_t first, Int_t last) const {
  //--------------------------------------------------------------------
  //This function "cooks" a track label. If label<0, this track is fake.
  //--------------------------------------------------------------------
  Int_t noc=t->GetNumberOfClusters();
  if (noc<10){
    //printf("\nnot founded prolongation\n\n\n");
    //t->Dump();
    return -1;
  }
  Int_t lb[160];
  Int_t mx[160];
  AliTPCclusterMI *clusters[160];
  //
  for (Int_t i=0;i<160;i++) {
    clusters[i]=0;
    lb[i]=mx[i]=0;
  }

  Int_t i;
  Int_t current=0;
  for (i=0; i<160 && current<noc; i++) {
    if (i<first) continue;
    if (i>last)  continue;
     Int_t index=t->GetClusterIndex2(i);
     if (index<=0) continue; 
     if (index&0x8000) continue;
     //     
     //clusters[current]=GetClusterMI(index);
     if (t->GetClusterPointer(i)){
       clusters[current]=t->GetClusterPointer(i);     
       current++;
     }
  }
  noc = current;
  //if (noc<5) return -1;
  Int_t lab=123456789;
  for (i=0; i<noc; i++) {
    AliTPCclusterMI *c=clusters[i];
    if (!c) continue;
    lab=TMath::Abs(c->GetLabel(0));
    Int_t j;
    for (j=0; j<noc; j++) if (lb[j]==lab || mx[j]==0) break;
    lb[j]=lab;
    (mx[j])++;
  }

  Int_t max=0;
  for (i=0; i<noc; i++) if (mx[i]>max) {max=mx[i]; lab=lb[i];}
    
  for (i=0; i<noc; i++) {
    AliTPCclusterMI *c=clusters[i]; 
    if (!c) continue;
    if (TMath::Abs(c->GetLabel(1)) == lab ||
        TMath::Abs(c->GetLabel(2)) == lab ) max++;
  }
  if (noc<=0) { lab=-1; return -1;}
  if ((1.- Float_t(max)/(noc)) > wrong) lab=-lab;

  else {
     Int_t tail=Int_t(0.10*noc);
     max=0;
     Int_t ind=0;
     for (i=1; i<160&&ind<tail; i++) {
       //       AliTPCclusterMI *c=clusters[noc-i];
       AliTPCclusterMI *c=clusters[i];
       if (!c) continue;
       if (lab == TMath::Abs(c->GetLabel(0)) ||
           lab == TMath::Abs(c->GetLabel(1)) ||
           lab == TMath::Abs(c->GetLabel(2))) max++;
       ind++;
     }
     if (max < Int_t(0.5*tail)) lab=-lab;
  }

  //  t->SetLabel(lab);
  return lab;
  //  delete[] lb;
  //delete[] mx;
  //delete[] clusters;
}


Int_t  AliTPCtracker::GetRowNumber(Double_t x[3]) const 
{
  //return pad row number for given x vector
  Float_t phi = TMath::ATan2(x[1],x[0]);
  if(phi<0) phi=2.*TMath::Pi()+phi;
  //  Get the local angle in the sector philoc
  const Float_t kRaddeg = 180/3.14159265358979312;
  Float_t phiangle   = (Int_t (phi*kRaddeg/20.) + 0.5)*20./kRaddeg;
  Double_t localx    = x[0]*TMath::Cos(phiangle)-x[1]*TMath::Sin(phiangle);
  return GetRowNumber(localx);
}



void AliTPCtracker::MakeESDBitmaps(AliTPCseed *t, AliESDtrack *esd)
{
  //-----------------------------------------------------------------------
  // Fill the cluster and sharing bitmaps of the track
  //-----------------------------------------------------------------------

  Int_t firstpoint = 0;
  Int_t lastpoint = 159;
  AliTPCTrackerPoint *point;
  AliTPCclusterMI    *cluster;
  
  Int_t nclsf = 0;
  TBits clusterMap(159);
  TBits sharedMap(159);
  TBits fitMap(159);
  for (int iter=firstpoint; iter<lastpoint; iter++) {
    // Change to cluster pointers to see if we have a cluster at given padrow

    cluster = t->GetClusterPointer(iter);
    if (cluster) {
      clusterMap.SetBitNumber(iter, kTRUE);
      point = t->GetTrackPoint(iter);
      if (point->IsShared())
	sharedMap.SetBitNumber(iter,kTRUE);
    }
    if (t->GetClusterIndex(iter) >= 0 && (t->GetClusterIndex(iter) & 0x8000) == 0) {
      fitMap.SetBitNumber(iter, kTRUE);
      nclsf++;
    }
  }
  esd->SetTPCClusterMap(clusterMap);
  esd->SetTPCSharedMap(sharedMap);
  esd->SetTPCFitMap(fitMap);
  if (nclsf != t->GetNumberOfClusters())
    AliDebug(3,Form("Inconsistency between ncls %d and indices %d (found %d)",t->GetNumberOfClusters(),nclsf,esd->GetTPCClusterMap().CountBits()));
}

Bool_t AliTPCtracker::IsFindable(AliTPCseed & track){
  //
  // return flag if there is findable cluster at given position
  //
  Float_t kDeltaZ=10;
  Float_t z = track.GetZ();
  
  if (TMath::Abs(z)<(AliTPCReconstructor::GetCtgRange()*track.GetX()+kDeltaZ) && 
      TMath::Abs(z)<fkParam->GetZLength(0) && 
      (TMath::Abs(track.GetSnp())<AliTPCReconstructor::GetMaxSnpTracker()))
    return kTRUE;
  return kFALSE;      
}


void AliTPCtracker::AddCovariance(AliTPCseed * seed){
  //
  // Adding systematic error estimate to the covariance matrix
  //                !!!! the systematic error for element 4 is in 1/GeV 
  // 03.03.2012     MI changed in respect to the previous versions
  const Double_t *param = AliTPCReconstructor::GetRecoParam()->GetSystematicError();
  //
  // use only the diagonal part if not specified otherwise
  if (!AliTPCReconstructor::GetRecoParam()->GetUseSystematicCorrelation()) return AddCovarianceAdd(seed);
  //
  Double_t *covarS= (Double_t*)seed->GetCovariance();
  Double_t factor[5]={1,1,1,1,1};
  factor[0]= TMath::Sqrt(TMath::Abs((covarS[0] + param[0]*param[0])/covarS[0]));
  factor[1]= TMath::Sqrt(TMath::Abs((covarS[2] + param[1]*param[1])/covarS[2]));
  factor[2]= TMath::Sqrt(TMath::Abs((covarS[5] + param[2]*param[2])/covarS[5]));
  factor[3]= TMath::Sqrt(TMath::Abs((covarS[9] + param[3]*param[3])/covarS[9]));
  factor[4]= TMath::Sqrt(TMath::Abs((covarS[14] +param[4]*param[4])/covarS[14]));
  //
  factor[0]=factor[2];
  factor[4]=factor[2];
  // 0
  // 1    2
  // 3    4    5
  // 6    7    8    9 
  // 10   11   12   13   14
  for (Int_t i=0; i<5; i++){
    for (Int_t j=i; j<5; j++){
      Int_t index=seed->GetIndex(i,j);
      covarS[index]*=factor[i]*factor[j];
    }
  }
}


void AliTPCtracker::AddCovarianceAdd(AliTPCseed * seed){
  //
  // Adding systematic error - as additive factor without correlation
  //
  //                !!!! the systematic error for element 4 is in 1/GeV 
  // 03.03.2012     MI changed in respect to the previous versions

  const Double_t *param = AliTPCReconstructor::GetRecoParam()->GetSystematicError();
  Double_t *covarIn= (Double_t*)seed->GetCovariance();
  Double_t covar[15];
  for (Int_t i=0;i<15;i++) covar[i]=0;
  // 0
  // 1    2
  // 3    4    5
  // 6    7    8    9 
  // 10   11   12   13   14
  covar[0] = param[0]*param[0];
  covar[2] = param[1]*param[1];
  covar[5] = param[2]*param[2];
  covar[9] = param[3]*param[3];
  covar[14]= param[4]*param[4];
  //
  covar[1]=TMath::Sqrt((covar[0]*covar[2]))*covarIn[1]/TMath::Sqrt((covarIn[0]*covarIn[2]));
  //
  covar[3]=TMath::Sqrt((covar[0]*covar[5]))*covarIn[3]/TMath::Sqrt((covarIn[0]*covarIn[5]));
  covar[4]=TMath::Sqrt((covar[2]*covar[5]))*covarIn[4]/TMath::Sqrt((covarIn[2]*covarIn[5]));
  //
  covar[6]=TMath::Sqrt((covar[0]*covar[9]))*covarIn[6]/TMath::Sqrt((covarIn[0]*covarIn[9]));
  covar[7]=TMath::Sqrt((covar[2]*covar[9]))*covarIn[7]/TMath::Sqrt((covarIn[2]*covarIn[9]));
  covar[8]=TMath::Sqrt((covar[5]*covar[9]))*covarIn[8]/TMath::Sqrt((covarIn[5]*covarIn[9]));
  //
  covar[10]=TMath::Sqrt((covar[0]*covar[14]))*covarIn[10]/TMath::Sqrt((covarIn[0]*covarIn[14]));
  covar[11]=TMath::Sqrt((covar[2]*covar[14]))*covarIn[11]/TMath::Sqrt((covarIn[2]*covarIn[14]));
  covar[12]=TMath::Sqrt((covar[5]*covar[14]))*covarIn[12]/TMath::Sqrt((covarIn[5]*covarIn[14]));
  covar[13]=TMath::Sqrt((covar[9]*covar[14]))*covarIn[13]/TMath::Sqrt((covarIn[9]*covarIn[14]));
  //
  seed->AddCovariance(covar);
}

//_____________________________________________________________________________
Bool_t  AliTPCtracker::IsTPCHVDipEvent(AliESDEvent const *esdEvent)
{
  //
  // check events affected by TPC HV dip
  //
  if(!esdEvent) return kFALSE;

  // Init TPC OCDB
  AliTPCcalibDB *db=AliTPCcalibDB::Instance();
  if(!db) return kFALSE;
  db->SetRun(esdEvent->GetRunNumber());

  // maximum allowed voltage before an event is identified as a dip event
  // and scanning period
  const Double_t kTPCHVdip          = db->GetParameters()->GetMaxDipVoltage(); 
  const Double_t dipEventScanPeriod = db->GetParameters()->GetVoltageDipScanPeriod();
  const Double_t tevSec             = esdEvent->GetTimeStamp();
  
  for(Int_t sector=0; sector<72; sector++)
  {
    // don't use excluded chambers, since the state is not defined at all
    if (!db->GetChamberHVStatus(sector)) continue;
    
    // get hv sensor of the chamber
    AliDCSSensor *sensor = db->GetChamberHVSensor(sector);
    if (!sensor) continue;
    TGraph *grSensor=sensor->GetGraph();
    if (!grSensor) continue;
    if (grSensor->GetN()<1) continue;
    
    // get median
    const Double_t median = db->GetChamberHighVoltageMedian(sector);
    if(median < 1.) continue;
    
    for (Int_t ipoint=0; ipoint<grSensor->GetN()-1; ++ipoint){
      Double_t nextTime=grSensor->GetX()[ipoint+1]*3600+sensor->GetStartTime();
      if (tevSec-dipEventScanPeriod>nextTime) continue;
      const Float_t deltaV=TMath::Abs(grSensor->GetY()[ipoint]-median);
      if (deltaV>kTPCHVdip) {
        AliDebug(3,Form("HV dip detected in ROC '%02d' with dV '%.2f' at time stamp '%.0f'",sector,deltaV,tevSec));
        return kTRUE;
      }
      if (nextTime>tevSec+dipEventScanPeriod) break;
    }
  }
  
  return kFALSE;
}

//________________________________________
void AliTPCtracker::MarkSeedFree(TObject *sd) 
{
  // account that this seed is "deleted" 
  AliTPCseed* seed = dynamic_cast<AliTPCseed*>(sd);
  if (!seed) {
    AliError(Form("Freeing of non-AliTPCseed %p from the pool is requested",sd)); 
    return;
  }
  int id = seed->GetPoolID();
  if (id<0) {
    AliError(Form("Freeing of seed %p NOT from the pool is requested",sd)); 
    return;
  }
  //  AliInfo(Form("%d %p",id, seed));
  fSeedsPool->RemoveAt(id);
  if (fFreeSeedsID.GetSize()<=fNFreeSeeds) fFreeSeedsID.Set( 2*fNFreeSeeds + 100 );
  fFreeSeedsID.GetArray()[fNFreeSeeds++] = id;
}

//________________________________________
TObject *&AliTPCtracker::NextFreeSeed()
{
  // return next free slot where the seed can be created
  fLastSeedID = fNFreeSeeds ? fFreeSeedsID.GetArray()[--fNFreeSeeds] : fSeedsPool->GetEntriesFast();
  //  AliInfo(Form("%d",fLastSeedID));
  return (*fSeedsPool)[ fLastSeedID ];
  //
}

//________________________________________
void AliTPCtracker::ResetSeedsPool()
{
  // mark all seeds in the pool as unused
  AliInfo(Form("CurrentSize: %d, BookedUpTo: %d, free: %d",fSeedsPool->GetSize(),fSeedsPool->GetEntriesFast(),fNFreeSeeds));
  fNFreeSeeds = 0;
  fSeedsPool->Clear("C"); // RS: nominally the seeds may allocate memory...
}

Int_t  AliTPCtracker::PropagateToRowHLT(AliTPCseed *pt, int nrow)
{
  AliTPCseed &t=*pt;
  Double_t x= GetXrow(nrow);
  Double_t  ymax= GetMaxY(nrow);
  Int_t rotate = 0;
  Int_t nRotations=0;
  int ret = 1;
  do{
    rotate = 0;
    if (!t.PropagateTo(x) ){
      //cout<<"can't propagate to row "<<nrow<<", x="<<t.GetX()<<" -> "<<x<<endl; 
      //t.Print();
      ret = 0;
      break;
    }
    t.SetRow(nrow);
    Double_t y = t.GetY();
    if( y > ymax ) {	
      if( rotate!=-1 ) rotate=1;
    } else if (y <-ymax) {
      if( rotate!=1 ) rotate = -1;
    }
    if( rotate==0 ) break;
    //cout<<"rotate at row "<<nrow<<": "<<rotate<<endl;
    if (!t.Rotate( rotate==1 ?fSectors->GetAlpha() :-fSectors->GetAlpha())) {
      //cout<<"can't rotate "<<endl; 
      ret=0;
      break;
    }
    nRotations+= rotate;
  }while(rotate!=0);
  if( nRotations!=0 ){
    int newSec= t.GetRelativeSector()+nRotations;
    if( newSec>=fN ) newSec-=fN;
    else if( newSec<0 ) newSec +=fN; 
    //cout<<"rotate at row "<<nrow<<": "<<nRotations<<" times "<<" sec "
    //<< t.GetRelativeSector()<<" -> "<<newSec<<endl;
    t.SetRelativeSector(newSec);
  }
  return ret;
}

void  AliTPCtracker::TrackFollowingHLT(TObjArray *const arr )
{
  //
  // try to track in parralel

  Int_t nRows=fOuterSec->GetNRows()+fInnerSec->GetNRows();
  fSectors=fInnerSec;

  Int_t nseed=arr->GetEntriesFast();
  //cout<<"Parallel tracking My.."<<endl;
  double shapeY2[160], shapeZ2[160];
  Int_t clusterIndex[160];
 
  for (Int_t iSeed=0; iSeed<nseed; iSeed++) {
    //if( iSeed!=1 ) continue;
    AliTPCseed *pt=(AliTPCseed*) (arr->UncheckedAt(iSeed));
    if (!pt) continue;
    AliTPCseed &t=*pt;    
    
    //cout <<"Pt "<<t.GetSigned1Pt()<<endl;
    
    // t.Print();
    
    for( int iter=0; iter<3; iter++ ){
            
      t.Reset();
      t.SetLastPoint(0);  // first cluster in track position
      t.SetFirstPoint(nRows-1);
      t.ResetCovariance(.1);
      t.SetNumberOfClusters(0);
      for( int i=0; i<nRows; i++ ){
	shapeY2[i]=1.;
	shapeZ2[i]=1.;
	clusterIndex[i]=-1;
	t.SetClusterIndex2(i,-1); 
	t.SetClusterIndex(i,-1); 
      }

     // pick up the clusters
      
      Double_t roady = 20.;
      Double_t roadz = 20.;
      double roadr = 5;

      AliTPCseed t0(t);
      t0.Reset();
      int nClusters = 0;      
      {
	t0.SetRelativeSector(t.GetRelativeSector());
	t0.SetLastPoint(0);  // first cluster in track position
	t0.SetFirstPoint(159);
	for (Int_t nr=0; nr<nRows; nr++){ 
	  if( nr<fInnerSec->GetNRows() ) fSectors=fInnerSec;
	  else fSectors=fOuterSec;

	  if( !PropagateToRowHLT(&t0, nr ) ){ break; }
	  if (TMath::Abs(t0.GetSnp())>AliTPCReconstructor::GetMaxSnpTracker()){
	    //cout<<"Snp is too big: "<<t0.GetSnp()<<endl; 
	    continue;
	  }
	  if (!IsActive(t0.GetRelativeSector(),nr)) {
	    continue;
	  }
	  
	  if( iter==0 ){
	    GetShape(&t0,nr); 
	    shapeY2[nr]=t0.GetCurrentSigmaY2();
	    shapeZ2[nr]=t0.GetCurrentSigmaZ2();
	  }

	  AliTPCtrackerRow &krow=GetRow(t0.GetRelativeSector(),nr);
	  if( !krow ) continue; 

	  t.SetClusterIndex2(nr,-3); // foundable
	  t.SetClusterIndex(nr,-3); 

	  AliTPCclusterMI *cl=0;
	  UInt_t uindex = 0;
	  cl = krow.FindNearest2(t0.GetY(),t0.GetZ(),roady,roadz,uindex); 
	  if (!cl ) continue;
	  double dy = cl->GetY()-t0.GetY();
	  double dz = cl->GetZ()-t0.GetZ();
	  double dr = sqrt(dy*dy+dz*dz);
	  if( dr>roadr ){ 
	    //cout<<"row "<<nr<<", best cluster r= "<<dr<<" y,z = "<<dy<<" "<<dz<<endl;
	    continue;
	  }
	  //cout<<"row "<<nr<<", found cluster r= "<<dr<<" y,z = "<<dy<<" "<<dz<<endl;

	  t0.SetClusterPointer(nr, cl);	  
	  clusterIndex[nr] = krow.GetIndex(uindex);	  
	  if( t0.GetFirstPoint()>nr ) t0.SetFirstPoint(nr);
	  t0.SetLastPoint(nr);
	  nClusters++;
	}
      }

      if( nClusters <3 ){
	//cout<<"NOT ENOUGTH CLUSTERS: "<<nClusters<<endl;
	break;
      }
      Int_t basePoints[3] = {t0.GetFirstPoint(),t0.GetFirstPoint(),t0.GetLastPoint()};

      // find midpoint
      {
	Int_t midRow = (t0.GetLastPoint()-t0.GetFirstPoint())/2;
	int dist=200;
	for( int nr=t0.GetFirstPoint()+1; nr< t0.GetLastPoint(); nr++){
	  if( !t0.GetClusterPointer(nr) ) continue;	  
	  int d = TMath::Abs(nr-midRow);
	  if( d < dist ){
	    dist = d;
	    basePoints[1] = nr;
	  }
	}
      }

      // first fit 3 base points
      if( 1||iter<2 ){
	//cout<<"Fit3: "<<endl;
 	for( int icl=0; icl<3; icl++){
	  int nr = basePoints[icl];
	  int lr=nr;
	  if( nr>=fInnerSec->GetNRows()){ 
	    lr = nr - fInnerSec->GetNRows();
	    fSectors=fOuterSec;
	  } else fSectors=fInnerSec;

	  AliTPCclusterMI *cl=t0.GetClusterPointer(nr);
	  if(!cl){
	    //cout<<"WRONG!!!!"<<endl; 
	    continue;
	  }
	  int iSec = cl->GetDetector() %fkNIS;
	  int rotate = iSec - t.GetRelativeSector();	
	  if( rotate!=0 ){
	    //cout<<"Rotate at row"<<nr<<" to "<<rotate<<" sectors"<<endl;
	    if (!t.Rotate( rotate*fSectors->GetAlpha()) ) {
	      //cout<<"can't rotate "<<endl; 
	      break;
	    }
	    t.SetRelativeSector(iSec);
	  }
	  Double_t x= cl->GetX();
	  if (!t.PropagateTo(x)){
	    //cout<<"can't propagate to x="<<x<<endl; 
	    break;
	  }    

	  if (TMath::Abs(t.GetSnp())>AliTPCReconstructor::GetMaxSnpTracker()){
	    //cout<<"Snp is too big: "<<t.GetSnp()<<endl; 
	    break;
	  }
	  //cout<<"fit3 : row "<<nr<<" ind = "<<clusterIndex[nr]<<endl;
	  
	  t.SetCurrentClusterIndex1(clusterIndex[nr]);
	  t.SetCurrentCluster(cl);
	  t.SetRow(lr);	
	  
	  t.SetErrorY2(shapeY2[nr]);
	  t.SetErrorZ2(shapeZ2[nr]);
	  if( icl==0 ){
	    double cov[15];
	    for( int j=0; j<15; j++ ) cov[j]=0;
	    cov[0]=10;
	    cov[2]=10;
	    cov[5]=.5;
	    cov[9]=.5;
	    cov[14]=1.;
	    t.AliExternalTrackParam::AddCovariance(cov);
	  }
	  if( !UpdateTrack(&t,0) ){
	    //cout<<"Can not update"<<endl;
	    //t.Print();
	    t.SetClusterIndex2(nr,-1); 
	    t.SetClusterIndex(nr,-1); 
	    t.SetClusterPointer(nr,0); 
	    break;
	  }      	
	  //t.SetClusterPointer(nr, cl);
	}
	
	//t.SetLastPoint(t0.GetLastPoint());
	//t.SetFirstPoint(t0.GetFirstPoint());

	//cout<<"Fit: "<<endl;
 	for (Int_t nr=t0.GetLastPoint(); nr>=t0.GetFirstPoint(); nr-- ){
	  int lr=nr;
	  if( nr>=fInnerSec->GetNRows()){ 
	    lr = nr - fInnerSec->GetNRows();
	    fSectors=fOuterSec;
	  } else fSectors=fInnerSec;
	  
	  if(1|| iter<2 ){
	    if( nr == basePoints[0] ) continue;
	    if( nr == basePoints[1] ) continue;
	    if( nr == basePoints[2] ) continue;
	  }
	  AliTPCclusterMI *cl=t0.GetClusterPointer(nr);
	  if(!cl) continue;
	  
	  int iSec = cl->GetDetector() %fkNIS;
	  int rotate = iSec - t.GetRelativeSector();	
	  if( rotate!=0 ){
	    //cout<<"Rotate at row"<<nr<<" to "<<rotate<<" sectors"<<endl;
	    if (!t.Rotate( rotate*fSectors->GetAlpha()) ) {
	      //cout<<"can't rotate "<<endl; 
	      break;
	    }
	    t.SetRelativeSector(iSec);
	  }
	  Double_t x= cl->GetX();
	  if (!t.PropagateTo(x)){
	    //cout<<"can't propagate to x="<<x<<endl; 
	    break;
	  }    
	  if (TMath::Abs(t.GetSnp())>AliTPCReconstructor::GetMaxSnpTracker()){
	    //cout<<"Snp is too big: "<<t.GetSnp()<<endl; 
	    break;
	  } 	
	  
	  //cout<<"fit: row "<<nr<<" ind = "<<clusterIndex[nr]<<endl;

	  t.SetCurrentClusterIndex1(clusterIndex[nr]);
	  t.SetCurrentCluster(cl);
	  t.SetRow(lr);	
	  t.SetErrorY2(shapeY2[nr]);
	  t.SetErrorZ2(shapeZ2[nr]);
	  
	  if( !UpdateTrack(&t,0) ){
	    //cout<<"Can not update"<<endl;
	    //t.Print();
	    t.SetClusterIndex2(nr,-1); 
	    t.SetClusterIndex(nr,-1); 
	    break;
	  }      	
	  //t.SetClusterPointer(nr, cl);
	}
      }
      //cout<<"After iter "<<iter<<": N clusters="<<t.GetNumberOfClusters()<<" : "<<nClusters<<endl;
    }

    //cout<<"fitted track"<<iSeed<<endl;
    //t.Print();
    //cout<<"Statistics: "<<endl;    
    Int_t foundable,found,shared;
    t.GetClusterStatistic(0,nRows, found, foundable, shared, kTRUE);
    t.SetNFoundable(foundable);
    //cout<<"found "<<found<<" foundable "<<foundable<<" shared "<<shared<<endl;
    
  }
}


TObjArray * AliTPCtracker::MakeSeedsHLT(const AliESDEvent *hltEvent)
{
  // tracking
  //  

  if( !hltEvent ) return 0;  
 

  Int_t nentr=hltEvent->GetNumberOfTracks();
 
  AliInfo(Form("Using %d HLT tracks for seeding",nentr));
 
  TObjArray * seeds = new TObjArray(nentr);

  Int_t nup=fOuterSec->GetNRows()+fInnerSec->GetNRows();
  Int_t index = 0;
  
  Int_t nTr=hltEvent->GetNumberOfTracks();      
    
  for( int itr=0; itr<nTr; itr++ ){
    //if( itr!=97 ) continue;
    const AliExternalTrackParam *param = hltEvent->GetTrack(itr)->GetTPCInnerParam();
    if( !param ) continue;
    //if( TMath::Abs(esdTr->GetSigned1Pt())>1 ) continue;
    //if( TMath::Abs(esdTr->GetTgl())>1. ) continue;
    AliTPCtrack tr;    
    tr.Set(param->GetX(),param->GetAlpha(),param->GetParameter(),param->GetCovariance());
    tr.SetNumberOfClusters(0);
    AliTPCseed * seed = new( NextFreeSeed() ) AliTPCseed(tr);

    Double_t alpha=seed->GetAlpha();// - fSectors->GetAlphaShift();
    if (alpha > 2.*TMath::Pi()) alpha -= 2.*TMath::Pi();
    if (alpha < 0.            ) alpha += 2.*TMath::Pi();
    //
    seed->SetRelativeSector(Int_t(alpha/fSectors->GetAlpha()+0.0001)%fN);
    Double_t alphaSec = fSectors->GetAlpha() * seed->GetRelativeSector() + fSectors->GetAlphaShift();
 
    if (alphaSec >= TMath::Pi()) alphaSec -= 2.*TMath::Pi();
    if (alphaSec < -TMath::Pi()) alphaSec += 2.*TMath::Pi();

    seed->Rotate(alphaSec - alpha);
    
    seed->SetPoolID(fLastSeedID);
    seed->SetIsSeeding(kTRUE);
    seed->SetSeed1(nup-1);
    seed->SetSeed2(nup-2);
    seed->SetSeedType(0);
    seed->SetFirstPoint(-1);
    seed->SetLastPoint(-1);
    seeds->AddLast(seed); // note, track is seed, don't free the seed
    index++;
    //if( index>3 ) break;
  }
 

  fSectors = fOuterSec;
  
  TrackFollowingHLT(seeds );

  nTr = seeds->GetEntriesFast();
  for( int itr=0; itr<nTr; itr++ ){
    AliTPCseed * seed = (AliTPCseed*) seeds->UncheckedAt(itr);
    if( !seed ) continue;
    //FollowBackProlongation(*seed,0);
    // cout<<seed->GetNumberOfClusters()<<endl;
    Int_t foundable,found,shared;
    seed->GetClusterStatistic(0,nup, found, foundable, shared, kTRUE);
    seed->SetNFoundable(foundable);
    //cout<<"found "<<found<<" foundable "<<foundable<<" shared "<<shared<<endl;
    //if ((found<0.55*foundable)  || shared>0.5*found ){// || (seed->GetSigmaY2()+seed->GetSigmaZ2())>0.5){
    //MarkSeedFree(seeds->RemoveAt(itr)); 
    //continue;
    //}
    if (seed->GetNumberOfClusters()<30 || 
	seed->GetNumberOfClusters() < seed->GetNFoundable()*0.6 || 
	seed->GetNShared()>0.4*seed->GetNumberOfClusters() ) {
      MarkSeedFree(seeds->RemoveAt(itr)); 
      continue;
    }      

    for( int ir=0; ir<nup; ir++){
      AliTPCclusterMI *c = seed->GetClusterPointer(ir);      
      if( c ) c->Use(10);
    }
  }
  std::cout<<"\n\nHLT tracks left: "<<seeds->GetEntries()<<" out of "<<hltEvent->GetNumberOfTracks()<<endl<<endl;
  return seeds;    
}

void AliTPCtracker::FillClusterOccupancyInfo()
{
  //fill the cluster occupancy info into the ESD friend
  AliESDfriend* esdFriend = static_cast<AliESDfriend*>(fEvent->FindListObject("AliESDfriend"));
  if (!esdFriend) return;

  for (Int_t isector=0; isector<18; isector++){
    AliTPCtrackerSector &iroc = fInnerSec[isector];
    AliTPCtrackerSector &oroc = fOuterSec[isector];
    //all clusters
    esdFriend->SetNclustersTPC(isector,   iroc.GetNClInSector(0));
    esdFriend->SetNclustersTPC(isector+18,iroc.GetNClInSector(1));
    esdFriend->SetNclustersTPC(isector+36,oroc.GetNClInSector(0));
    esdFriend->SetNclustersTPC(isector+54,oroc.GetNClInSector(1));
    //clusters used in tracking
    esdFriend->SetNclustersTPCused(isector,    iroc.GetNClUsedInSector(0));
    esdFriend->SetNclustersTPCused(isector+18, iroc.GetNClUsedInSector(1));
    esdFriend->SetNclustersTPCused(isector+36, oroc.GetNClUsedInSector(0));
    esdFriend->SetNclustersTPCused(isector+54, oroc.GetNClUsedInSector(1));
  }
}
 AliTPCtracker.cxx:1
 AliTPCtracker.cxx:2
 AliTPCtracker.cxx:3
 AliTPCtracker.cxx:4
 AliTPCtracker.cxx:5
 AliTPCtracker.cxx:6
 AliTPCtracker.cxx:7
 AliTPCtracker.cxx:8
 AliTPCtracker.cxx:9
 AliTPCtracker.cxx:10
 AliTPCtracker.cxx:11
 AliTPCtracker.cxx:12
 AliTPCtracker.cxx:13
 AliTPCtracker.cxx:14
 AliTPCtracker.cxx:15
 AliTPCtracker.cxx:16
 AliTPCtracker.cxx:17
 AliTPCtracker.cxx:18
 AliTPCtracker.cxx:19
 AliTPCtracker.cxx:20
 AliTPCtracker.cxx:21
 AliTPCtracker.cxx:22
 AliTPCtracker.cxx:23
 AliTPCtracker.cxx:24
 AliTPCtracker.cxx:25
 AliTPCtracker.cxx:26
 AliTPCtracker.cxx:27
 AliTPCtracker.cxx:28
 AliTPCtracker.cxx:29
 AliTPCtracker.cxx:30
 AliTPCtracker.cxx:31
 AliTPCtracker.cxx:32
 AliTPCtracker.cxx:33
 AliTPCtracker.cxx:34
 AliTPCtracker.cxx:35
 AliTPCtracker.cxx:36
 AliTPCtracker.cxx:37
 AliTPCtracker.cxx:38
 AliTPCtracker.cxx:39
 AliTPCtracker.cxx:40
 AliTPCtracker.cxx:41
 AliTPCtracker.cxx:42
 AliTPCtracker.cxx:43
 AliTPCtracker.cxx:44
 AliTPCtracker.cxx:45
 AliTPCtracker.cxx:46
 AliTPCtracker.cxx:47
 AliTPCtracker.cxx:48
 AliTPCtracker.cxx:49
 AliTPCtracker.cxx:50
 AliTPCtracker.cxx:51
 AliTPCtracker.cxx:52
 AliTPCtracker.cxx:53
 AliTPCtracker.cxx:54
 AliTPCtracker.cxx:55
 AliTPCtracker.cxx:56
 AliTPCtracker.cxx:57
 AliTPCtracker.cxx:58
 AliTPCtracker.cxx:59
 AliTPCtracker.cxx:60
 AliTPCtracker.cxx:61
 AliTPCtracker.cxx:62
 AliTPCtracker.cxx:63
 AliTPCtracker.cxx:64
 AliTPCtracker.cxx:65
 AliTPCtracker.cxx:66
 AliTPCtracker.cxx:67
 AliTPCtracker.cxx:68
 AliTPCtracker.cxx:69
 AliTPCtracker.cxx:70
 AliTPCtracker.cxx:71
 AliTPCtracker.cxx:72
 AliTPCtracker.cxx:73
 AliTPCtracker.cxx:74
 AliTPCtracker.cxx:75
 AliTPCtracker.cxx:76
 AliTPCtracker.cxx:77
 AliTPCtracker.cxx:78
 AliTPCtracker.cxx:79
 AliTPCtracker.cxx:80
 AliTPCtracker.cxx:81
 AliTPCtracker.cxx:82
 AliTPCtracker.cxx:83
 AliTPCtracker.cxx:84
 AliTPCtracker.cxx:85
 AliTPCtracker.cxx:86
 AliTPCtracker.cxx:87
 AliTPCtracker.cxx:88
 AliTPCtracker.cxx:89
 AliTPCtracker.cxx:90
 AliTPCtracker.cxx:91
 AliTPCtracker.cxx:92
 AliTPCtracker.cxx:93
 AliTPCtracker.cxx:94
 AliTPCtracker.cxx:95
 AliTPCtracker.cxx:96
 AliTPCtracker.cxx:97
 AliTPCtracker.cxx:98
 AliTPCtracker.cxx:99
 AliTPCtracker.cxx:100
 AliTPCtracker.cxx:101
 AliTPCtracker.cxx:102
 AliTPCtracker.cxx:103
 AliTPCtracker.cxx:104
 AliTPCtracker.cxx:105
 AliTPCtracker.cxx:106
 AliTPCtracker.cxx:107
 AliTPCtracker.cxx:108
 AliTPCtracker.cxx:109
 AliTPCtracker.cxx:110
 AliTPCtracker.cxx:111
 AliTPCtracker.cxx:112
 AliTPCtracker.cxx:113
 AliTPCtracker.cxx:114
 AliTPCtracker.cxx:115
 AliTPCtracker.cxx:116
 AliTPCtracker.cxx:117
 AliTPCtracker.cxx:118
 AliTPCtracker.cxx:119
 AliTPCtracker.cxx:120
 AliTPCtracker.cxx:121
 AliTPCtracker.cxx:122
 AliTPCtracker.cxx:123
 AliTPCtracker.cxx:124
 AliTPCtracker.cxx:125
 AliTPCtracker.cxx:126
 AliTPCtracker.cxx:127
 AliTPCtracker.cxx:128
 AliTPCtracker.cxx:129
 AliTPCtracker.cxx:130
 AliTPCtracker.cxx:131
 AliTPCtracker.cxx:132
 AliTPCtracker.cxx:133
 AliTPCtracker.cxx:134
 AliTPCtracker.cxx:135
 AliTPCtracker.cxx:136
 AliTPCtracker.cxx:137
 AliTPCtracker.cxx:138
 AliTPCtracker.cxx:139
 AliTPCtracker.cxx:140
 AliTPCtracker.cxx:141
 AliTPCtracker.cxx:142
 AliTPCtracker.cxx:143
 AliTPCtracker.cxx:144
 AliTPCtracker.cxx:145
 AliTPCtracker.cxx:146
 AliTPCtracker.cxx:147
 AliTPCtracker.cxx:148
 AliTPCtracker.cxx:149
 AliTPCtracker.cxx:150
 AliTPCtracker.cxx:151
 AliTPCtracker.cxx:152
 AliTPCtracker.cxx:153
 AliTPCtracker.cxx:154
 AliTPCtracker.cxx:155
 AliTPCtracker.cxx:156
 AliTPCtracker.cxx:157
 AliTPCtracker.cxx:158
 AliTPCtracker.cxx:159
 AliTPCtracker.cxx:160
 AliTPCtracker.cxx:161
 AliTPCtracker.cxx:162
 AliTPCtracker.cxx:163
 AliTPCtracker.cxx:164
 AliTPCtracker.cxx:165
 AliTPCtracker.cxx:166
 AliTPCtracker.cxx:167
 AliTPCtracker.cxx:168
 AliTPCtracker.cxx:169
 AliTPCtracker.cxx:170
 AliTPCtracker.cxx:171
 AliTPCtracker.cxx:172
 AliTPCtracker.cxx:173
 AliTPCtracker.cxx:174
 AliTPCtracker.cxx:175
 AliTPCtracker.cxx:176
 AliTPCtracker.cxx:177
 AliTPCtracker.cxx:178
 AliTPCtracker.cxx:179
 AliTPCtracker.cxx:180
 AliTPCtracker.cxx:181
 AliTPCtracker.cxx:182
 AliTPCtracker.cxx:183
 AliTPCtracker.cxx:184
 AliTPCtracker.cxx:185
 AliTPCtracker.cxx:186
 AliTPCtracker.cxx:187
 AliTPCtracker.cxx:188
 AliTPCtracker.cxx:189
 AliTPCtracker.cxx:190
 AliTPCtracker.cxx:191
 AliTPCtracker.cxx:192
 AliTPCtracker.cxx:193
 AliTPCtracker.cxx:194
 AliTPCtracker.cxx:195
 AliTPCtracker.cxx:196
 AliTPCtracker.cxx:197
 AliTPCtracker.cxx:198
 AliTPCtracker.cxx:199
 AliTPCtracker.cxx:200
 AliTPCtracker.cxx:201
 AliTPCtracker.cxx:202
 AliTPCtracker.cxx:203
 AliTPCtracker.cxx:204
 AliTPCtracker.cxx:205
 AliTPCtracker.cxx:206
 AliTPCtracker.cxx:207
 AliTPCtracker.cxx:208
 AliTPCtracker.cxx:209
 AliTPCtracker.cxx:210
 AliTPCtracker.cxx:211
 AliTPCtracker.cxx:212
 AliTPCtracker.cxx:213
 AliTPCtracker.cxx:214
 AliTPCtracker.cxx:215
 AliTPCtracker.cxx:216
 AliTPCtracker.cxx:217
 AliTPCtracker.cxx:218
 AliTPCtracker.cxx:219
 AliTPCtracker.cxx:220
 AliTPCtracker.cxx:221
 AliTPCtracker.cxx:222
 AliTPCtracker.cxx:223
 AliTPCtracker.cxx:224
 AliTPCtracker.cxx:225
 AliTPCtracker.cxx:226
 AliTPCtracker.cxx:227
 AliTPCtracker.cxx:228
 AliTPCtracker.cxx:229
 AliTPCtracker.cxx:230
 AliTPCtracker.cxx:231
 AliTPCtracker.cxx:232
 AliTPCtracker.cxx:233
 AliTPCtracker.cxx:234
 AliTPCtracker.cxx:235
 AliTPCtracker.cxx:236
 AliTPCtracker.cxx:237
 AliTPCtracker.cxx:238
 AliTPCtracker.cxx:239
 AliTPCtracker.cxx:240
 AliTPCtracker.cxx:241
 AliTPCtracker.cxx:242
 AliTPCtracker.cxx:243
 AliTPCtracker.cxx:244
 AliTPCtracker.cxx:245
 AliTPCtracker.cxx:246
 AliTPCtracker.cxx:247
 AliTPCtracker.cxx:248
 AliTPCtracker.cxx:249
 AliTPCtracker.cxx:250
 AliTPCtracker.cxx:251
 AliTPCtracker.cxx:252
 AliTPCtracker.cxx:253
 AliTPCtracker.cxx:254
 AliTPCtracker.cxx:255
 AliTPCtracker.cxx:256
 AliTPCtracker.cxx:257
 AliTPCtracker.cxx:258
 AliTPCtracker.cxx:259
 AliTPCtracker.cxx:260
 AliTPCtracker.cxx:261
 AliTPCtracker.cxx:262
 AliTPCtracker.cxx:263
 AliTPCtracker.cxx:264
 AliTPCtracker.cxx:265
 AliTPCtracker.cxx:266
 AliTPCtracker.cxx:267
 AliTPCtracker.cxx:268
 AliTPCtracker.cxx:269
 AliTPCtracker.cxx:270
 AliTPCtracker.cxx:271
 AliTPCtracker.cxx:272
 AliTPCtracker.cxx:273
 AliTPCtracker.cxx:274
 AliTPCtracker.cxx:275
 AliTPCtracker.cxx:276
 AliTPCtracker.cxx:277
 AliTPCtracker.cxx:278
 AliTPCtracker.cxx:279
 AliTPCtracker.cxx:280
 AliTPCtracker.cxx:281
 AliTPCtracker.cxx:282
 AliTPCtracker.cxx:283
 AliTPCtracker.cxx:284
 AliTPCtracker.cxx:285
 AliTPCtracker.cxx:286
 AliTPCtracker.cxx:287
 AliTPCtracker.cxx:288
 AliTPCtracker.cxx:289
 AliTPCtracker.cxx:290
 AliTPCtracker.cxx:291
 AliTPCtracker.cxx:292
 AliTPCtracker.cxx:293
 AliTPCtracker.cxx:294
 AliTPCtracker.cxx:295
 AliTPCtracker.cxx:296
 AliTPCtracker.cxx:297
 AliTPCtracker.cxx:298
 AliTPCtracker.cxx:299
 AliTPCtracker.cxx:300
 AliTPCtracker.cxx:301
 AliTPCtracker.cxx:302
 AliTPCtracker.cxx:303
 AliTPCtracker.cxx:304
 AliTPCtracker.cxx:305
 AliTPCtracker.cxx:306
 AliTPCtracker.cxx:307
 AliTPCtracker.cxx:308
 AliTPCtracker.cxx:309
 AliTPCtracker.cxx:310
 AliTPCtracker.cxx:311
 AliTPCtracker.cxx:312
 AliTPCtracker.cxx:313
 AliTPCtracker.cxx:314
 AliTPCtracker.cxx:315
 AliTPCtracker.cxx:316
 AliTPCtracker.cxx:317
 AliTPCtracker.cxx:318
 AliTPCtracker.cxx:319
 AliTPCtracker.cxx:320
 AliTPCtracker.cxx:321
 AliTPCtracker.cxx:322
 AliTPCtracker.cxx:323
 AliTPCtracker.cxx:324
 AliTPCtracker.cxx:325
 AliTPCtracker.cxx:326
 AliTPCtracker.cxx:327
 AliTPCtracker.cxx:328
 AliTPCtracker.cxx:329
 AliTPCtracker.cxx:330
 AliTPCtracker.cxx:331
 AliTPCtracker.cxx:332
 AliTPCtracker.cxx:333
 AliTPCtracker.cxx:334
 AliTPCtracker.cxx:335
 AliTPCtracker.cxx:336
 AliTPCtracker.cxx:337
 AliTPCtracker.cxx:338
 AliTPCtracker.cxx:339
 AliTPCtracker.cxx:340
 AliTPCtracker.cxx:341
 AliTPCtracker.cxx:342
 AliTPCtracker.cxx:343
 AliTPCtracker.cxx:344
 AliTPCtracker.cxx:345
 AliTPCtracker.cxx:346
 AliTPCtracker.cxx:347
 AliTPCtracker.cxx:348
 AliTPCtracker.cxx:349
 AliTPCtracker.cxx:350
 AliTPCtracker.cxx:351
 AliTPCtracker.cxx:352
 AliTPCtracker.cxx:353
 AliTPCtracker.cxx:354
 AliTPCtracker.cxx:355
 AliTPCtracker.cxx:356
 AliTPCtracker.cxx:357
 AliTPCtracker.cxx:358
 AliTPCtracker.cxx:359
 AliTPCtracker.cxx:360
 AliTPCtracker.cxx:361
 AliTPCtracker.cxx:362
 AliTPCtracker.cxx:363
 AliTPCtracker.cxx:364
 AliTPCtracker.cxx:365
 AliTPCtracker.cxx:366
 AliTPCtracker.cxx:367
 AliTPCtracker.cxx:368
 AliTPCtracker.cxx:369
 AliTPCtracker.cxx:370
 AliTPCtracker.cxx:371
 AliTPCtracker.cxx:372
 AliTPCtracker.cxx:373
 AliTPCtracker.cxx:374
 AliTPCtracker.cxx:375
 AliTPCtracker.cxx:376
 AliTPCtracker.cxx:377
 AliTPCtracker.cxx:378
 AliTPCtracker.cxx:379
 AliTPCtracker.cxx:380
 AliTPCtracker.cxx:381
 AliTPCtracker.cxx:382
 AliTPCtracker.cxx:383
 AliTPCtracker.cxx:384
 AliTPCtracker.cxx:385
 AliTPCtracker.cxx:386
 AliTPCtracker.cxx:387
 AliTPCtracker.cxx:388
 AliTPCtracker.cxx:389
 AliTPCtracker.cxx:390
 AliTPCtracker.cxx:391
 AliTPCtracker.cxx:392
 AliTPCtracker.cxx:393
 AliTPCtracker.cxx:394
 AliTPCtracker.cxx:395
 AliTPCtracker.cxx:396
 AliTPCtracker.cxx:397
 AliTPCtracker.cxx:398
 AliTPCtracker.cxx:399
 AliTPCtracker.cxx:400
 AliTPCtracker.cxx:401
 AliTPCtracker.cxx:402
 AliTPCtracker.cxx:403
 AliTPCtracker.cxx:404
 AliTPCtracker.cxx:405
 AliTPCtracker.cxx:406
 AliTPCtracker.cxx:407
 AliTPCtracker.cxx:408
 AliTPCtracker.cxx:409
 AliTPCtracker.cxx:410
 AliTPCtracker.cxx:411
 AliTPCtracker.cxx:412
 AliTPCtracker.cxx:413
 AliTPCtracker.cxx:414
 AliTPCtracker.cxx:415
 AliTPCtracker.cxx:416
 AliTPCtracker.cxx:417
 AliTPCtracker.cxx:418
 AliTPCtracker.cxx:419
 AliTPCtracker.cxx:420
 AliTPCtracker.cxx:421
 AliTPCtracker.cxx:422
 AliTPCtracker.cxx:423
 AliTPCtracker.cxx:424
 AliTPCtracker.cxx:425
 AliTPCtracker.cxx:426
 AliTPCtracker.cxx:427
 AliTPCtracker.cxx:428
 AliTPCtracker.cxx:429
 AliTPCtracker.cxx:430
 AliTPCtracker.cxx:431
 AliTPCtracker.cxx:432
 AliTPCtracker.cxx:433
 AliTPCtracker.cxx:434
 AliTPCtracker.cxx:435
 AliTPCtracker.cxx:436
 AliTPCtracker.cxx:437
 AliTPCtracker.cxx:438
 AliTPCtracker.cxx:439
 AliTPCtracker.cxx:440
 AliTPCtracker.cxx:441
 AliTPCtracker.cxx:442
 AliTPCtracker.cxx:443
 AliTPCtracker.cxx:444
 AliTPCtracker.cxx:445
 AliTPCtracker.cxx:446
 AliTPCtracker.cxx:447
 AliTPCtracker.cxx:448
 AliTPCtracker.cxx:449
 AliTPCtracker.cxx:450
 AliTPCtracker.cxx:451
 AliTPCtracker.cxx:452
 AliTPCtracker.cxx:453
 AliTPCtracker.cxx:454
 AliTPCtracker.cxx:455
 AliTPCtracker.cxx:456
 AliTPCtracker.cxx:457
 AliTPCtracker.cxx:458
 AliTPCtracker.cxx:459
 AliTPCtracker.cxx:460
 AliTPCtracker.cxx:461
 AliTPCtracker.cxx:462
 AliTPCtracker.cxx:463
 AliTPCtracker.cxx:464
 AliTPCtracker.cxx:465
 AliTPCtracker.cxx:466
 AliTPCtracker.cxx:467
 AliTPCtracker.cxx:468
 AliTPCtracker.cxx:469
 AliTPCtracker.cxx:470
 AliTPCtracker.cxx:471
 AliTPCtracker.cxx:472
 AliTPCtracker.cxx:473
 AliTPCtracker.cxx:474
 AliTPCtracker.cxx:475
 AliTPCtracker.cxx:476
 AliTPCtracker.cxx:477
 AliTPCtracker.cxx:478
 AliTPCtracker.cxx:479
 AliTPCtracker.cxx:480
 AliTPCtracker.cxx:481
 AliTPCtracker.cxx:482
 AliTPCtracker.cxx:483
 AliTPCtracker.cxx:484
 AliTPCtracker.cxx:485
 AliTPCtracker.cxx:486
 AliTPCtracker.cxx:487
 AliTPCtracker.cxx:488
 AliTPCtracker.cxx:489
 AliTPCtracker.cxx:490
 AliTPCtracker.cxx:491
 AliTPCtracker.cxx:492
 AliTPCtracker.cxx:493
 AliTPCtracker.cxx:494
 AliTPCtracker.cxx:495
 AliTPCtracker.cxx:496
 AliTPCtracker.cxx:497
 AliTPCtracker.cxx:498
 AliTPCtracker.cxx:499
 AliTPCtracker.cxx:500
 AliTPCtracker.cxx:501
 AliTPCtracker.cxx:502
 AliTPCtracker.cxx:503
 AliTPCtracker.cxx:504
 AliTPCtracker.cxx:505
 AliTPCtracker.cxx:506
 AliTPCtracker.cxx:507
 AliTPCtracker.cxx:508
 AliTPCtracker.cxx:509
 AliTPCtracker.cxx:510
 AliTPCtracker.cxx:511
 AliTPCtracker.cxx:512
 AliTPCtracker.cxx:513
 AliTPCtracker.cxx:514
 AliTPCtracker.cxx:515
 AliTPCtracker.cxx:516
 AliTPCtracker.cxx:517
 AliTPCtracker.cxx:518
 AliTPCtracker.cxx:519
 AliTPCtracker.cxx:520
 AliTPCtracker.cxx:521
 AliTPCtracker.cxx:522
 AliTPCtracker.cxx:523
 AliTPCtracker.cxx:524
 AliTPCtracker.cxx:525
 AliTPCtracker.cxx:526
 AliTPCtracker.cxx:527
 AliTPCtracker.cxx:528
 AliTPCtracker.cxx:529
 AliTPCtracker.cxx:530
 AliTPCtracker.cxx:531
 AliTPCtracker.cxx:532
 AliTPCtracker.cxx:533
 AliTPCtracker.cxx:534
 AliTPCtracker.cxx:535
 AliTPCtracker.cxx:536
 AliTPCtracker.cxx:537
 AliTPCtracker.cxx:538
 AliTPCtracker.cxx:539
 AliTPCtracker.cxx:540
 AliTPCtracker.cxx:541
 AliTPCtracker.cxx:542
 AliTPCtracker.cxx:543
 AliTPCtracker.cxx:544
 AliTPCtracker.cxx:545
 AliTPCtracker.cxx:546
 AliTPCtracker.cxx:547
 AliTPCtracker.cxx:548
 AliTPCtracker.cxx:549
 AliTPCtracker.cxx:550
 AliTPCtracker.cxx:551
 AliTPCtracker.cxx:552
 AliTPCtracker.cxx:553
 AliTPCtracker.cxx:554
 AliTPCtracker.cxx:555
 AliTPCtracker.cxx:556
 AliTPCtracker.cxx:557
 AliTPCtracker.cxx:558
 AliTPCtracker.cxx:559
 AliTPCtracker.cxx:560
 AliTPCtracker.cxx:561
 AliTPCtracker.cxx:562
 AliTPCtracker.cxx:563
 AliTPCtracker.cxx:564
 AliTPCtracker.cxx:565
 AliTPCtracker.cxx:566
 AliTPCtracker.cxx:567
 AliTPCtracker.cxx:568
 AliTPCtracker.cxx:569
 AliTPCtracker.cxx:570
 AliTPCtracker.cxx:571
 AliTPCtracker.cxx:572
 AliTPCtracker.cxx:573
 AliTPCtracker.cxx:574
 AliTPCtracker.cxx:575
 AliTPCtracker.cxx:576
 AliTPCtracker.cxx:577
 AliTPCtracker.cxx:578
 AliTPCtracker.cxx:579
 AliTPCtracker.cxx:580
 AliTPCtracker.cxx:581
 AliTPCtracker.cxx:582
 AliTPCtracker.cxx:583
 AliTPCtracker.cxx:584
 AliTPCtracker.cxx:585
 AliTPCtracker.cxx:586
 AliTPCtracker.cxx:587
 AliTPCtracker.cxx:588
 AliTPCtracker.cxx:589
 AliTPCtracker.cxx:590
 AliTPCtracker.cxx:591
 AliTPCtracker.cxx:592
 AliTPCtracker.cxx:593
 AliTPCtracker.cxx:594
 AliTPCtracker.cxx:595
 AliTPCtracker.cxx:596
 AliTPCtracker.cxx:597
 AliTPCtracker.cxx:598
 AliTPCtracker.cxx:599
 AliTPCtracker.cxx:600
 AliTPCtracker.cxx:601
 AliTPCtracker.cxx:602
 AliTPCtracker.cxx:603
 AliTPCtracker.cxx:604
 AliTPCtracker.cxx:605
 AliTPCtracker.cxx:606
 AliTPCtracker.cxx:607
 AliTPCtracker.cxx:608
 AliTPCtracker.cxx:609
 AliTPCtracker.cxx:610
 AliTPCtracker.cxx:611
 AliTPCtracker.cxx:612
 AliTPCtracker.cxx:613
 AliTPCtracker.cxx:614
 AliTPCtracker.cxx:615
 AliTPCtracker.cxx:616
 AliTPCtracker.cxx:617
 AliTPCtracker.cxx:618
 AliTPCtracker.cxx:619
 AliTPCtracker.cxx:620
 AliTPCtracker.cxx:621
 AliTPCtracker.cxx:622
 AliTPCtracker.cxx:623
 AliTPCtracker.cxx:624
 AliTPCtracker.cxx:625
 AliTPCtracker.cxx:626
 AliTPCtracker.cxx:627
 AliTPCtracker.cxx:628
 AliTPCtracker.cxx:629
 AliTPCtracker.cxx:630
 AliTPCtracker.cxx:631
 AliTPCtracker.cxx:632
 AliTPCtracker.cxx:633
 AliTPCtracker.cxx:634
 AliTPCtracker.cxx:635
 AliTPCtracker.cxx:636
 AliTPCtracker.cxx:637
 AliTPCtracker.cxx:638
 AliTPCtracker.cxx:639
 AliTPCtracker.cxx:640
 AliTPCtracker.cxx:641
 AliTPCtracker.cxx:642
 AliTPCtracker.cxx:643
 AliTPCtracker.cxx:644
 AliTPCtracker.cxx:645
 AliTPCtracker.cxx:646
 AliTPCtracker.cxx:647
 AliTPCtracker.cxx:648
 AliTPCtracker.cxx:649
 AliTPCtracker.cxx:650
 AliTPCtracker.cxx:651
 AliTPCtracker.cxx:652
 AliTPCtracker.cxx:653
 AliTPCtracker.cxx:654
 AliTPCtracker.cxx:655
 AliTPCtracker.cxx:656
 AliTPCtracker.cxx:657
 AliTPCtracker.cxx:658
 AliTPCtracker.cxx:659
 AliTPCtracker.cxx:660
 AliTPCtracker.cxx:661
 AliTPCtracker.cxx:662
 AliTPCtracker.cxx:663
 AliTPCtracker.cxx:664
 AliTPCtracker.cxx:665
 AliTPCtracker.cxx:666
 AliTPCtracker.cxx:667
 AliTPCtracker.cxx:668
 AliTPCtracker.cxx:669
 AliTPCtracker.cxx:670
 AliTPCtracker.cxx:671
 AliTPCtracker.cxx:672
 AliTPCtracker.cxx:673
 AliTPCtracker.cxx:674
 AliTPCtracker.cxx:675
 AliTPCtracker.cxx:676
 AliTPCtracker.cxx:677
 AliTPCtracker.cxx:678
 AliTPCtracker.cxx:679
 AliTPCtracker.cxx:680
 AliTPCtracker.cxx:681
 AliTPCtracker.cxx:682
 AliTPCtracker.cxx:683
 AliTPCtracker.cxx:684
 AliTPCtracker.cxx:685
 AliTPCtracker.cxx:686
 AliTPCtracker.cxx:687
 AliTPCtracker.cxx:688
 AliTPCtracker.cxx:689
 AliTPCtracker.cxx:690
 AliTPCtracker.cxx:691
 AliTPCtracker.cxx:692
 AliTPCtracker.cxx:693
 AliTPCtracker.cxx:694
 AliTPCtracker.cxx:695
 AliTPCtracker.cxx:696
 AliTPCtracker.cxx:697
 AliTPCtracker.cxx:698
 AliTPCtracker.cxx:699
 AliTPCtracker.cxx:700
 AliTPCtracker.cxx:701
 AliTPCtracker.cxx:702
 AliTPCtracker.cxx:703
 AliTPCtracker.cxx:704
 AliTPCtracker.cxx:705
 AliTPCtracker.cxx:706
 AliTPCtracker.cxx:707
 AliTPCtracker.cxx:708
 AliTPCtracker.cxx:709
 AliTPCtracker.cxx:710
 AliTPCtracker.cxx:711
 AliTPCtracker.cxx:712
 AliTPCtracker.cxx:713
 AliTPCtracker.cxx:714
 AliTPCtracker.cxx:715
 AliTPCtracker.cxx:716
 AliTPCtracker.cxx:717
 AliTPCtracker.cxx:718
 AliTPCtracker.cxx:719
 AliTPCtracker.cxx:720
 AliTPCtracker.cxx:721
 AliTPCtracker.cxx:722
 AliTPCtracker.cxx:723
 AliTPCtracker.cxx:724
 AliTPCtracker.cxx:725
 AliTPCtracker.cxx:726
 AliTPCtracker.cxx:727
 AliTPCtracker.cxx:728
 AliTPCtracker.cxx:729
 AliTPCtracker.cxx:730
 AliTPCtracker.cxx:731
 AliTPCtracker.cxx:732
 AliTPCtracker.cxx:733
 AliTPCtracker.cxx:734
 AliTPCtracker.cxx:735
 AliTPCtracker.cxx:736
 AliTPCtracker.cxx:737
 AliTPCtracker.cxx:738
 AliTPCtracker.cxx:739
 AliTPCtracker.cxx:740
 AliTPCtracker.cxx:741
 AliTPCtracker.cxx:742
 AliTPCtracker.cxx:743
 AliTPCtracker.cxx:744
 AliTPCtracker.cxx:745
 AliTPCtracker.cxx:746
 AliTPCtracker.cxx:747
 AliTPCtracker.cxx:748
 AliTPCtracker.cxx:749
 AliTPCtracker.cxx:750
 AliTPCtracker.cxx:751
 AliTPCtracker.cxx:752
 AliTPCtracker.cxx:753
 AliTPCtracker.cxx:754
 AliTPCtracker.cxx:755
 AliTPCtracker.cxx:756
 AliTPCtracker.cxx:757
 AliTPCtracker.cxx:758
 AliTPCtracker.cxx:759
 AliTPCtracker.cxx:760
 AliTPCtracker.cxx:761
 AliTPCtracker.cxx:762
 AliTPCtracker.cxx:763
 AliTPCtracker.cxx:764
 AliTPCtracker.cxx:765
 AliTPCtracker.cxx:766
 AliTPCtracker.cxx:767
 AliTPCtracker.cxx:768
 AliTPCtracker.cxx:769
 AliTPCtracker.cxx:770
 AliTPCtracker.cxx:771
 AliTPCtracker.cxx:772
 AliTPCtracker.cxx:773
 AliTPCtracker.cxx:774
 AliTPCtracker.cxx:775
 AliTPCtracker.cxx:776
 AliTPCtracker.cxx:777
 AliTPCtracker.cxx:778
 AliTPCtracker.cxx:779
 AliTPCtracker.cxx:780
 AliTPCtracker.cxx:781
 AliTPCtracker.cxx:782
 AliTPCtracker.cxx:783
 AliTPCtracker.cxx:784
 AliTPCtracker.cxx:785
 AliTPCtracker.cxx:786
 AliTPCtracker.cxx:787
 AliTPCtracker.cxx:788
 AliTPCtracker.cxx:789
 AliTPCtracker.cxx:790
 AliTPCtracker.cxx:791
 AliTPCtracker.cxx:792
 AliTPCtracker.cxx:793
 AliTPCtracker.cxx:794
 AliTPCtracker.cxx:795
 AliTPCtracker.cxx:796
 AliTPCtracker.cxx:797
 AliTPCtracker.cxx:798
 AliTPCtracker.cxx:799
 AliTPCtracker.cxx:800
 AliTPCtracker.cxx:801
 AliTPCtracker.cxx:802
 AliTPCtracker.cxx:803
 AliTPCtracker.cxx:804
 AliTPCtracker.cxx:805
 AliTPCtracker.cxx:806
 AliTPCtracker.cxx:807
 AliTPCtracker.cxx:808
 AliTPCtracker.cxx:809
 AliTPCtracker.cxx:810
 AliTPCtracker.cxx:811
 AliTPCtracker.cxx:812
 AliTPCtracker.cxx:813
 AliTPCtracker.cxx:814
 AliTPCtracker.cxx:815
 AliTPCtracker.cxx:816
 AliTPCtracker.cxx:817
 AliTPCtracker.cxx:818
 AliTPCtracker.cxx:819
 AliTPCtracker.cxx:820
 AliTPCtracker.cxx:821
 AliTPCtracker.cxx:822
 AliTPCtracker.cxx:823
 AliTPCtracker.cxx:824
 AliTPCtracker.cxx:825
 AliTPCtracker.cxx:826
 AliTPCtracker.cxx:827
 AliTPCtracker.cxx:828
 AliTPCtracker.cxx:829
 AliTPCtracker.cxx:830
 AliTPCtracker.cxx:831
 AliTPCtracker.cxx:832
 AliTPCtracker.cxx:833
 AliTPCtracker.cxx:834
 AliTPCtracker.cxx:835
 AliTPCtracker.cxx:836
 AliTPCtracker.cxx:837
 AliTPCtracker.cxx:838
 AliTPCtracker.cxx:839
 AliTPCtracker.cxx:840
 AliTPCtracker.cxx:841
 AliTPCtracker.cxx:842
 AliTPCtracker.cxx:843
 AliTPCtracker.cxx:844
 AliTPCtracker.cxx:845
 AliTPCtracker.cxx:846
 AliTPCtracker.cxx:847
 AliTPCtracker.cxx:848
 AliTPCtracker.cxx:849
 AliTPCtracker.cxx:850
 AliTPCtracker.cxx:851
 AliTPCtracker.cxx:852
 AliTPCtracker.cxx:853
 AliTPCtracker.cxx:854
 AliTPCtracker.cxx:855
 AliTPCtracker.cxx:856
 AliTPCtracker.cxx:857
 AliTPCtracker.cxx:858
 AliTPCtracker.cxx:859
 AliTPCtracker.cxx:860
 AliTPCtracker.cxx:861
 AliTPCtracker.cxx:862
 AliTPCtracker.cxx:863
 AliTPCtracker.cxx:864
 AliTPCtracker.cxx:865
 AliTPCtracker.cxx:866
 AliTPCtracker.cxx:867
 AliTPCtracker.cxx:868
 AliTPCtracker.cxx:869
 AliTPCtracker.cxx:870
 AliTPCtracker.cxx:871
 AliTPCtracker.cxx:872
 AliTPCtracker.cxx:873
 AliTPCtracker.cxx:874
 AliTPCtracker.cxx:875
 AliTPCtracker.cxx:876
 AliTPCtracker.cxx:877
 AliTPCtracker.cxx:878
 AliTPCtracker.cxx:879
 AliTPCtracker.cxx:880
 AliTPCtracker.cxx:881
 AliTPCtracker.cxx:882
 AliTPCtracker.cxx:883
 AliTPCtracker.cxx:884
 AliTPCtracker.cxx:885
 AliTPCtracker.cxx:886
 AliTPCtracker.cxx:887
 AliTPCtracker.cxx:888
 AliTPCtracker.cxx:889
 AliTPCtracker.cxx:890
 AliTPCtracker.cxx:891
 AliTPCtracker.cxx:892
 AliTPCtracker.cxx:893
 AliTPCtracker.cxx:894
 AliTPCtracker.cxx:895
 AliTPCtracker.cxx:896
 AliTPCtracker.cxx:897
 AliTPCtracker.cxx:898
 AliTPCtracker.cxx:899
 AliTPCtracker.cxx:900
 AliTPCtracker.cxx:901
 AliTPCtracker.cxx:902
 AliTPCtracker.cxx:903
 AliTPCtracker.cxx:904
 AliTPCtracker.cxx:905
 AliTPCtracker.cxx:906
 AliTPCtracker.cxx:907
 AliTPCtracker.cxx:908
 AliTPCtracker.cxx:909
 AliTPCtracker.cxx:910
 AliTPCtracker.cxx:911
 AliTPCtracker.cxx:912
 AliTPCtracker.cxx:913
 AliTPCtracker.cxx:914
 AliTPCtracker.cxx:915
 AliTPCtracker.cxx:916
 AliTPCtracker.cxx:917
 AliTPCtracker.cxx:918
 AliTPCtracker.cxx:919
 AliTPCtracker.cxx:920
 AliTPCtracker.cxx:921
 AliTPCtracker.cxx:922
 AliTPCtracker.cxx:923
 AliTPCtracker.cxx:924
 AliTPCtracker.cxx:925
 AliTPCtracker.cxx:926
 AliTPCtracker.cxx:927
 AliTPCtracker.cxx:928
 AliTPCtracker.cxx:929
 AliTPCtracker.cxx:930
 AliTPCtracker.cxx:931
 AliTPCtracker.cxx:932
 AliTPCtracker.cxx:933
 AliTPCtracker.cxx:934
 AliTPCtracker.cxx:935
 AliTPCtracker.cxx:936
 AliTPCtracker.cxx:937
 AliTPCtracker.cxx:938
 AliTPCtracker.cxx:939
 AliTPCtracker.cxx:940
 AliTPCtracker.cxx:941
 AliTPCtracker.cxx:942
 AliTPCtracker.cxx:943
 AliTPCtracker.cxx:944
 AliTPCtracker.cxx:945
 AliTPCtracker.cxx:946
 AliTPCtracker.cxx:947
 AliTPCtracker.cxx:948
 AliTPCtracker.cxx:949
 AliTPCtracker.cxx:950
 AliTPCtracker.cxx:951
 AliTPCtracker.cxx:952
 AliTPCtracker.cxx:953
 AliTPCtracker.cxx:954
 AliTPCtracker.cxx:955
 AliTPCtracker.cxx:956
 AliTPCtracker.cxx:957
 AliTPCtracker.cxx:958
 AliTPCtracker.cxx:959
 AliTPCtracker.cxx:960
 AliTPCtracker.cxx:961
 AliTPCtracker.cxx:962
 AliTPCtracker.cxx:963
 AliTPCtracker.cxx:964
 AliTPCtracker.cxx:965
 AliTPCtracker.cxx:966
 AliTPCtracker.cxx:967
 AliTPCtracker.cxx:968
 AliTPCtracker.cxx:969
 AliTPCtracker.cxx:970
 AliTPCtracker.cxx:971
 AliTPCtracker.cxx:972
 AliTPCtracker.cxx:973
 AliTPCtracker.cxx:974
 AliTPCtracker.cxx:975
 AliTPCtracker.cxx:976
 AliTPCtracker.cxx:977
 AliTPCtracker.cxx:978
 AliTPCtracker.cxx:979
 AliTPCtracker.cxx:980
 AliTPCtracker.cxx:981
 AliTPCtracker.cxx:982
 AliTPCtracker.cxx:983
 AliTPCtracker.cxx:984
 AliTPCtracker.cxx:985
 AliTPCtracker.cxx:986
 AliTPCtracker.cxx:987
 AliTPCtracker.cxx:988
 AliTPCtracker.cxx:989
 AliTPCtracker.cxx:990
 AliTPCtracker.cxx:991
 AliTPCtracker.cxx:992
 AliTPCtracker.cxx:993
 AliTPCtracker.cxx:994
 AliTPCtracker.cxx:995
 AliTPCtracker.cxx:996
 AliTPCtracker.cxx:997
 AliTPCtracker.cxx:998
 AliTPCtracker.cxx:999
 AliTPCtracker.cxx:1000
 AliTPCtracker.cxx:1001
 AliTPCtracker.cxx:1002
 AliTPCtracker.cxx:1003
 AliTPCtracker.cxx:1004
 AliTPCtracker.cxx:1005
 AliTPCtracker.cxx:1006
 AliTPCtracker.cxx:1007
 AliTPCtracker.cxx:1008
 AliTPCtracker.cxx:1009
 AliTPCtracker.cxx:1010
 AliTPCtracker.cxx:1011
 AliTPCtracker.cxx:1012
 AliTPCtracker.cxx:1013
 AliTPCtracker.cxx:1014
 AliTPCtracker.cxx:1015
 AliTPCtracker.cxx:1016
 AliTPCtracker.cxx:1017
 AliTPCtracker.cxx:1018
 AliTPCtracker.cxx:1019
 AliTPCtracker.cxx:1020
 AliTPCtracker.cxx:1021
 AliTPCtracker.cxx:1022
 AliTPCtracker.cxx:1023
 AliTPCtracker.cxx:1024
 AliTPCtracker.cxx:1025
 AliTPCtracker.cxx:1026
 AliTPCtracker.cxx:1027
 AliTPCtracker.cxx:1028
 AliTPCtracker.cxx:1029
 AliTPCtracker.cxx:1030
 AliTPCtracker.cxx:1031
 AliTPCtracker.cxx:1032
 AliTPCtracker.cxx:1033
 AliTPCtracker.cxx:1034
 AliTPCtracker.cxx:1035
 AliTPCtracker.cxx:1036
 AliTPCtracker.cxx:1037
 AliTPCtracker.cxx:1038
 AliTPCtracker.cxx:1039
 AliTPCtracker.cxx:1040
 AliTPCtracker.cxx:1041
 AliTPCtracker.cxx:1042
 AliTPCtracker.cxx:1043
 AliTPCtracker.cxx:1044
 AliTPCtracker.cxx:1045
 AliTPCtracker.cxx:1046
 AliTPCtracker.cxx:1047
 AliTPCtracker.cxx:1048
 AliTPCtracker.cxx:1049
 AliTPCtracker.cxx:1050
 AliTPCtracker.cxx:1051
 AliTPCtracker.cxx:1052
 AliTPCtracker.cxx:1053
 AliTPCtracker.cxx:1054
 AliTPCtracker.cxx:1055
 AliTPCtracker.cxx:1056
 AliTPCtracker.cxx:1057
 AliTPCtracker.cxx:1058
 AliTPCtracker.cxx:1059
 AliTPCtracker.cxx:1060
 AliTPCtracker.cxx:1061
 AliTPCtracker.cxx:1062
 AliTPCtracker.cxx:1063
 AliTPCtracker.cxx:1064
 AliTPCtracker.cxx:1065
 AliTPCtracker.cxx:1066
 AliTPCtracker.cxx:1067
 AliTPCtracker.cxx:1068
 AliTPCtracker.cxx:1069
 AliTPCtracker.cxx:1070
 AliTPCtracker.cxx:1071
 AliTPCtracker.cxx:1072
 AliTPCtracker.cxx:1073
 AliTPCtracker.cxx:1074
 AliTPCtracker.cxx:1075
 AliTPCtracker.cxx:1076
 AliTPCtracker.cxx:1077
 AliTPCtracker.cxx:1078
 AliTPCtracker.cxx:1079
 AliTPCtracker.cxx:1080
 AliTPCtracker.cxx:1081
 AliTPCtracker.cxx:1082
 AliTPCtracker.cxx:1083
 AliTPCtracker.cxx:1084
 AliTPCtracker.cxx:1085
 AliTPCtracker.cxx:1086
 AliTPCtracker.cxx:1087
 AliTPCtracker.cxx:1088
 AliTPCtracker.cxx:1089
 AliTPCtracker.cxx:1090
 AliTPCtracker.cxx:1091
 AliTPCtracker.cxx:1092
 AliTPCtracker.cxx:1093
 AliTPCtracker.cxx:1094
 AliTPCtracker.cxx:1095
 AliTPCtracker.cxx:1096
 AliTPCtracker.cxx:1097
 AliTPCtracker.cxx:1098
 AliTPCtracker.cxx:1099
 AliTPCtracker.cxx:1100
 AliTPCtracker.cxx:1101
 AliTPCtracker.cxx:1102
 AliTPCtracker.cxx:1103
 AliTPCtracker.cxx:1104
 AliTPCtracker.cxx:1105
 AliTPCtracker.cxx:1106
 AliTPCtracker.cxx:1107
 AliTPCtracker.cxx:1108
 AliTPCtracker.cxx:1109
 AliTPCtracker.cxx:1110
 AliTPCtracker.cxx:1111
 AliTPCtracker.cxx:1112
 AliTPCtracker.cxx:1113
 AliTPCtracker.cxx:1114
 AliTPCtracker.cxx:1115
 AliTPCtracker.cxx:1116
 AliTPCtracker.cxx:1117
 AliTPCtracker.cxx:1118
 AliTPCtracker.cxx:1119
 AliTPCtracker.cxx:1120
 AliTPCtracker.cxx:1121
 AliTPCtracker.cxx:1122
 AliTPCtracker.cxx:1123
 AliTPCtracker.cxx:1124
 AliTPCtracker.cxx:1125
 AliTPCtracker.cxx:1126
 AliTPCtracker.cxx:1127
 AliTPCtracker.cxx:1128
 AliTPCtracker.cxx:1129
 AliTPCtracker.cxx:1130
 AliTPCtracker.cxx:1131
 AliTPCtracker.cxx:1132
 AliTPCtracker.cxx:1133
 AliTPCtracker.cxx:1134
 AliTPCtracker.cxx:1135
 AliTPCtracker.cxx:1136
 AliTPCtracker.cxx:1137
 AliTPCtracker.cxx:1138
 AliTPCtracker.cxx:1139
 AliTPCtracker.cxx:1140
 AliTPCtracker.cxx:1141
 AliTPCtracker.cxx:1142
 AliTPCtracker.cxx:1143
 AliTPCtracker.cxx:1144
 AliTPCtracker.cxx:1145
 AliTPCtracker.cxx:1146
 AliTPCtracker.cxx:1147
 AliTPCtracker.cxx:1148
 AliTPCtracker.cxx:1149
 AliTPCtracker.cxx:1150
 AliTPCtracker.cxx:1151
 AliTPCtracker.cxx:1152
 AliTPCtracker.cxx:1153
 AliTPCtracker.cxx:1154
 AliTPCtracker.cxx:1155
 AliTPCtracker.cxx:1156
 AliTPCtracker.cxx:1157
 AliTPCtracker.cxx:1158
 AliTPCtracker.cxx:1159
 AliTPCtracker.cxx:1160
 AliTPCtracker.cxx:1161
 AliTPCtracker.cxx:1162
 AliTPCtracker.cxx:1163
 AliTPCtracker.cxx:1164
 AliTPCtracker.cxx:1165
 AliTPCtracker.cxx:1166
 AliTPCtracker.cxx:1167
 AliTPCtracker.cxx:1168
 AliTPCtracker.cxx:1169
 AliTPCtracker.cxx:1170
 AliTPCtracker.cxx:1171
 AliTPCtracker.cxx:1172
 AliTPCtracker.cxx:1173
 AliTPCtracker.cxx:1174
 AliTPCtracker.cxx:1175
 AliTPCtracker.cxx:1176
 AliTPCtracker.cxx:1177
 AliTPCtracker.cxx:1178
 AliTPCtracker.cxx:1179
 AliTPCtracker.cxx:1180
 AliTPCtracker.cxx:1181
 AliTPCtracker.cxx:1182
 AliTPCtracker.cxx:1183
 AliTPCtracker.cxx:1184
 AliTPCtracker.cxx:1185
 AliTPCtracker.cxx:1186
 AliTPCtracker.cxx:1187
 AliTPCtracker.cxx:1188
 AliTPCtracker.cxx:1189
 AliTPCtracker.cxx:1190
 AliTPCtracker.cxx:1191
 AliTPCtracker.cxx:1192
 AliTPCtracker.cxx:1193
 AliTPCtracker.cxx:1194
 AliTPCtracker.cxx:1195
 AliTPCtracker.cxx:1196
 AliTPCtracker.cxx:1197
 AliTPCtracker.cxx:1198
 AliTPCtracker.cxx:1199
 AliTPCtracker.cxx:1200
 AliTPCtracker.cxx:1201
 AliTPCtracker.cxx:1202
 AliTPCtracker.cxx:1203
 AliTPCtracker.cxx:1204
 AliTPCtracker.cxx:1205
 AliTPCtracker.cxx:1206
 AliTPCtracker.cxx:1207
 AliTPCtracker.cxx:1208
 AliTPCtracker.cxx:1209
 AliTPCtracker.cxx:1210
 AliTPCtracker.cxx:1211
 AliTPCtracker.cxx:1212
 AliTPCtracker.cxx:1213
 AliTPCtracker.cxx:1214
 AliTPCtracker.cxx:1215
 AliTPCtracker.cxx:1216
 AliTPCtracker.cxx:1217
 AliTPCtracker.cxx:1218
 AliTPCtracker.cxx:1219
 AliTPCtracker.cxx:1220
 AliTPCtracker.cxx:1221
 AliTPCtracker.cxx:1222
 AliTPCtracker.cxx:1223
 AliTPCtracker.cxx:1224
 AliTPCtracker.cxx:1225
 AliTPCtracker.cxx:1226
 AliTPCtracker.cxx:1227
 AliTPCtracker.cxx:1228
 AliTPCtracker.cxx:1229
 AliTPCtracker.cxx:1230
 AliTPCtracker.cxx:1231
 AliTPCtracker.cxx:1232
 AliTPCtracker.cxx:1233
 AliTPCtracker.cxx:1234
 AliTPCtracker.cxx:1235
 AliTPCtracker.cxx:1236
 AliTPCtracker.cxx:1237
 AliTPCtracker.cxx:1238
 AliTPCtracker.cxx:1239
 AliTPCtracker.cxx:1240
 AliTPCtracker.cxx:1241
 AliTPCtracker.cxx:1242
 AliTPCtracker.cxx:1243
 AliTPCtracker.cxx:1244
 AliTPCtracker.cxx:1245
 AliTPCtracker.cxx:1246
 AliTPCtracker.cxx:1247
 AliTPCtracker.cxx:1248
 AliTPCtracker.cxx:1249
 AliTPCtracker.cxx:1250
 AliTPCtracker.cxx:1251
 AliTPCtracker.cxx:1252
 AliTPCtracker.cxx:1253
 AliTPCtracker.cxx:1254
 AliTPCtracker.cxx:1255
 AliTPCtracker.cxx:1256
 AliTPCtracker.cxx:1257
 AliTPCtracker.cxx:1258
 AliTPCtracker.cxx:1259
 AliTPCtracker.cxx:1260
 AliTPCtracker.cxx:1261
 AliTPCtracker.cxx:1262
 AliTPCtracker.cxx:1263
 AliTPCtracker.cxx:1264
 AliTPCtracker.cxx:1265
 AliTPCtracker.cxx:1266
 AliTPCtracker.cxx:1267
 AliTPCtracker.cxx:1268
 AliTPCtracker.cxx:1269
 AliTPCtracker.cxx:1270
 AliTPCtracker.cxx:1271
 AliTPCtracker.cxx:1272
 AliTPCtracker.cxx:1273
 AliTPCtracker.cxx:1274
 AliTPCtracker.cxx:1275
 AliTPCtracker.cxx:1276
 AliTPCtracker.cxx:1277
 AliTPCtracker.cxx:1278
 AliTPCtracker.cxx:1279
 AliTPCtracker.cxx:1280
 AliTPCtracker.cxx:1281
 AliTPCtracker.cxx:1282
 AliTPCtracker.cxx:1283
 AliTPCtracker.cxx:1284
 AliTPCtracker.cxx:1285
 AliTPCtracker.cxx:1286
 AliTPCtracker.cxx:1287
 AliTPCtracker.cxx:1288
 AliTPCtracker.cxx:1289
 AliTPCtracker.cxx:1290
 AliTPCtracker.cxx:1291
 AliTPCtracker.cxx:1292
 AliTPCtracker.cxx:1293
 AliTPCtracker.cxx:1294
 AliTPCtracker.cxx:1295
 AliTPCtracker.cxx:1296
 AliTPCtracker.cxx:1297
 AliTPCtracker.cxx:1298
 AliTPCtracker.cxx:1299
 AliTPCtracker.cxx:1300
 AliTPCtracker.cxx:1301
 AliTPCtracker.cxx:1302
 AliTPCtracker.cxx:1303
 AliTPCtracker.cxx:1304
 AliTPCtracker.cxx:1305
 AliTPCtracker.cxx:1306
 AliTPCtracker.cxx:1307
 AliTPCtracker.cxx:1308
 AliTPCtracker.cxx:1309
 AliTPCtracker.cxx:1310
 AliTPCtracker.cxx:1311
 AliTPCtracker.cxx:1312
 AliTPCtracker.cxx:1313
 AliTPCtracker.cxx:1314
 AliTPCtracker.cxx:1315
 AliTPCtracker.cxx:1316
 AliTPCtracker.cxx:1317
 AliTPCtracker.cxx:1318
 AliTPCtracker.cxx:1319
 AliTPCtracker.cxx:1320
 AliTPCtracker.cxx:1321
 AliTPCtracker.cxx:1322
 AliTPCtracker.cxx:1323
 AliTPCtracker.cxx:1324
 AliTPCtracker.cxx:1325
 AliTPCtracker.cxx:1326
 AliTPCtracker.cxx:1327
 AliTPCtracker.cxx:1328
 AliTPCtracker.cxx:1329
 AliTPCtracker.cxx:1330
 AliTPCtracker.cxx:1331
 AliTPCtracker.cxx:1332
 AliTPCtracker.cxx:1333
 AliTPCtracker.cxx:1334
 AliTPCtracker.cxx:1335
 AliTPCtracker.cxx:1336
 AliTPCtracker.cxx:1337
 AliTPCtracker.cxx:1338
 AliTPCtracker.cxx:1339
 AliTPCtracker.cxx:1340
 AliTPCtracker.cxx:1341
 AliTPCtracker.cxx:1342
 AliTPCtracker.cxx:1343
 AliTPCtracker.cxx:1344
 AliTPCtracker.cxx:1345
 AliTPCtracker.cxx:1346
 AliTPCtracker.cxx:1347
 AliTPCtracker.cxx:1348
 AliTPCtracker.cxx:1349
 AliTPCtracker.cxx:1350
 AliTPCtracker.cxx:1351
 AliTPCtracker.cxx:1352
 AliTPCtracker.cxx:1353
 AliTPCtracker.cxx:1354
 AliTPCtracker.cxx:1355
 AliTPCtracker.cxx:1356
 AliTPCtracker.cxx:1357
 AliTPCtracker.cxx:1358
 AliTPCtracker.cxx:1359
 AliTPCtracker.cxx:1360
 AliTPCtracker.cxx:1361
 AliTPCtracker.cxx:1362
 AliTPCtracker.cxx:1363
 AliTPCtracker.cxx:1364
 AliTPCtracker.cxx:1365
 AliTPCtracker.cxx:1366
 AliTPCtracker.cxx:1367
 AliTPCtracker.cxx:1368
 AliTPCtracker.cxx:1369
 AliTPCtracker.cxx:1370
 AliTPCtracker.cxx:1371
 AliTPCtracker.cxx:1372
 AliTPCtracker.cxx:1373
 AliTPCtracker.cxx:1374
 AliTPCtracker.cxx:1375
 AliTPCtracker.cxx:1376
 AliTPCtracker.cxx:1377
 AliTPCtracker.cxx:1378
 AliTPCtracker.cxx:1379
 AliTPCtracker.cxx:1380
 AliTPCtracker.cxx:1381
 AliTPCtracker.cxx:1382
 AliTPCtracker.cxx:1383
 AliTPCtracker.cxx:1384
 AliTPCtracker.cxx:1385
 AliTPCtracker.cxx:1386
 AliTPCtracker.cxx:1387
 AliTPCtracker.cxx:1388
 AliTPCtracker.cxx:1389
 AliTPCtracker.cxx:1390
 AliTPCtracker.cxx:1391
 AliTPCtracker.cxx:1392
 AliTPCtracker.cxx:1393
 AliTPCtracker.cxx:1394
 AliTPCtracker.cxx:1395
 AliTPCtracker.cxx:1396
 AliTPCtracker.cxx:1397
 AliTPCtracker.cxx:1398
 AliTPCtracker.cxx:1399
 AliTPCtracker.cxx:1400
 AliTPCtracker.cxx:1401
 AliTPCtracker.cxx:1402
 AliTPCtracker.cxx:1403
 AliTPCtracker.cxx:1404
 AliTPCtracker.cxx:1405
 AliTPCtracker.cxx:1406
 AliTPCtracker.cxx:1407
 AliTPCtracker.cxx:1408
 AliTPCtracker.cxx:1409
 AliTPCtracker.cxx:1410
 AliTPCtracker.cxx:1411
 AliTPCtracker.cxx:1412
 AliTPCtracker.cxx:1413
 AliTPCtracker.cxx:1414
 AliTPCtracker.cxx:1415
 AliTPCtracker.cxx:1416
 AliTPCtracker.cxx:1417
 AliTPCtracker.cxx:1418
 AliTPCtracker.cxx:1419
 AliTPCtracker.cxx:1420
 AliTPCtracker.cxx:1421
 AliTPCtracker.cxx:1422
 AliTPCtracker.cxx:1423
 AliTPCtracker.cxx:1424
 AliTPCtracker.cxx:1425
 AliTPCtracker.cxx:1426
 AliTPCtracker.cxx:1427
 AliTPCtracker.cxx:1428
 AliTPCtracker.cxx:1429
 AliTPCtracker.cxx:1430
 AliTPCtracker.cxx:1431
 AliTPCtracker.cxx:1432
 AliTPCtracker.cxx:1433
 AliTPCtracker.cxx:1434
 AliTPCtracker.cxx:1435
 AliTPCtracker.cxx:1436
 AliTPCtracker.cxx:1437
 AliTPCtracker.cxx:1438
 AliTPCtracker.cxx:1439
 AliTPCtracker.cxx:1440
 AliTPCtracker.cxx:1441
 AliTPCtracker.cxx:1442
 AliTPCtracker.cxx:1443
 AliTPCtracker.cxx:1444
 AliTPCtracker.cxx:1445
 AliTPCtracker.cxx:1446
 AliTPCtracker.cxx:1447
 AliTPCtracker.cxx:1448
 AliTPCtracker.cxx:1449
 AliTPCtracker.cxx:1450
 AliTPCtracker.cxx:1451
 AliTPCtracker.cxx:1452
 AliTPCtracker.cxx:1453
 AliTPCtracker.cxx:1454
 AliTPCtracker.cxx:1455
 AliTPCtracker.cxx:1456
 AliTPCtracker.cxx:1457
 AliTPCtracker.cxx:1458
 AliTPCtracker.cxx:1459
 AliTPCtracker.cxx:1460
 AliTPCtracker.cxx:1461
 AliTPCtracker.cxx:1462
 AliTPCtracker.cxx:1463
 AliTPCtracker.cxx:1464
 AliTPCtracker.cxx:1465
 AliTPCtracker.cxx:1466
 AliTPCtracker.cxx:1467
 AliTPCtracker.cxx:1468
 AliTPCtracker.cxx:1469
 AliTPCtracker.cxx:1470
 AliTPCtracker.cxx:1471
 AliTPCtracker.cxx:1472
 AliTPCtracker.cxx:1473
 AliTPCtracker.cxx:1474
 AliTPCtracker.cxx:1475
 AliTPCtracker.cxx:1476
 AliTPCtracker.cxx:1477
 AliTPCtracker.cxx:1478
 AliTPCtracker.cxx:1479
 AliTPCtracker.cxx:1480
 AliTPCtracker.cxx:1481
 AliTPCtracker.cxx:1482
 AliTPCtracker.cxx:1483
 AliTPCtracker.cxx:1484
 AliTPCtracker.cxx:1485
 AliTPCtracker.cxx:1486
 AliTPCtracker.cxx:1487
 AliTPCtracker.cxx:1488
 AliTPCtracker.cxx:1489
 AliTPCtracker.cxx:1490
 AliTPCtracker.cxx:1491
 AliTPCtracker.cxx:1492
 AliTPCtracker.cxx:1493
 AliTPCtracker.cxx:1494
 AliTPCtracker.cxx:1495
 AliTPCtracker.cxx:1496
 AliTPCtracker.cxx:1497
 AliTPCtracker.cxx:1498
 AliTPCtracker.cxx:1499
 AliTPCtracker.cxx:1500
 AliTPCtracker.cxx:1501
 AliTPCtracker.cxx:1502
 AliTPCtracker.cxx:1503
 AliTPCtracker.cxx:1504
 AliTPCtracker.cxx:1505
 AliTPCtracker.cxx:1506
 AliTPCtracker.cxx:1507
 AliTPCtracker.cxx:1508
 AliTPCtracker.cxx:1509
 AliTPCtracker.cxx:1510
 AliTPCtracker.cxx:1511
 AliTPCtracker.cxx:1512
 AliTPCtracker.cxx:1513
 AliTPCtracker.cxx:1514
 AliTPCtracker.cxx:1515
 AliTPCtracker.cxx:1516
 AliTPCtracker.cxx:1517
 AliTPCtracker.cxx:1518
 AliTPCtracker.cxx:1519
 AliTPCtracker.cxx:1520
 AliTPCtracker.cxx:1521
 AliTPCtracker.cxx:1522
 AliTPCtracker.cxx:1523
 AliTPCtracker.cxx:1524
 AliTPCtracker.cxx:1525
 AliTPCtracker.cxx:1526
 AliTPCtracker.cxx:1527
 AliTPCtracker.cxx:1528
 AliTPCtracker.cxx:1529
 AliTPCtracker.cxx:1530
 AliTPCtracker.cxx:1531
 AliTPCtracker.cxx:1532
 AliTPCtracker.cxx:1533
 AliTPCtracker.cxx:1534
 AliTPCtracker.cxx:1535
 AliTPCtracker.cxx:1536
 AliTPCtracker.cxx:1537
 AliTPCtracker.cxx:1538
 AliTPCtracker.cxx:1539
 AliTPCtracker.cxx:1540
 AliTPCtracker.cxx:1541
 AliTPCtracker.cxx:1542
 AliTPCtracker.cxx:1543
 AliTPCtracker.cxx:1544
 AliTPCtracker.cxx:1545
 AliTPCtracker.cxx:1546
 AliTPCtracker.cxx:1547
 AliTPCtracker.cxx:1548
 AliTPCtracker.cxx:1549
 AliTPCtracker.cxx:1550
 AliTPCtracker.cxx:1551
 AliTPCtracker.cxx:1552
 AliTPCtracker.cxx:1553
 AliTPCtracker.cxx:1554
 AliTPCtracker.cxx:1555
 AliTPCtracker.cxx:1556
 AliTPCtracker.cxx:1557
 AliTPCtracker.cxx:1558
 AliTPCtracker.cxx:1559
 AliTPCtracker.cxx:1560
 AliTPCtracker.cxx:1561
 AliTPCtracker.cxx:1562
 AliTPCtracker.cxx:1563
 AliTPCtracker.cxx:1564
 AliTPCtracker.cxx:1565
 AliTPCtracker.cxx:1566
 AliTPCtracker.cxx:1567
 AliTPCtracker.cxx:1568
 AliTPCtracker.cxx:1569
 AliTPCtracker.cxx:1570
 AliTPCtracker.cxx:1571
 AliTPCtracker.cxx:1572
 AliTPCtracker.cxx:1573
 AliTPCtracker.cxx:1574
 AliTPCtracker.cxx:1575
 AliTPCtracker.cxx:1576
 AliTPCtracker.cxx:1577
 AliTPCtracker.cxx:1578
 AliTPCtracker.cxx:1579
 AliTPCtracker.cxx:1580
 AliTPCtracker.cxx:1581
 AliTPCtracker.cxx:1582
 AliTPCtracker.cxx:1583
 AliTPCtracker.cxx:1584
 AliTPCtracker.cxx:1585
 AliTPCtracker.cxx:1586
 AliTPCtracker.cxx:1587
 AliTPCtracker.cxx:1588
 AliTPCtracker.cxx:1589
 AliTPCtracker.cxx:1590
 AliTPCtracker.cxx:1591
 AliTPCtracker.cxx:1592
 AliTPCtracker.cxx:1593
 AliTPCtracker.cxx:1594
 AliTPCtracker.cxx:1595
 AliTPCtracker.cxx:1596
 AliTPCtracker.cxx:1597
 AliTPCtracker.cxx:1598
 AliTPCtracker.cxx:1599
 AliTPCtracker.cxx:1600
 AliTPCtracker.cxx:1601
 AliTPCtracker.cxx:1602
 AliTPCtracker.cxx:1603
 AliTPCtracker.cxx:1604
 AliTPCtracker.cxx:1605
 AliTPCtracker.cxx:1606
 AliTPCtracker.cxx:1607
 AliTPCtracker.cxx:1608
 AliTPCtracker.cxx:1609
 AliTPCtracker.cxx:1610
 AliTPCtracker.cxx:1611
 AliTPCtracker.cxx:1612
 AliTPCtracker.cxx:1613
 AliTPCtracker.cxx:1614
 AliTPCtracker.cxx:1615
 AliTPCtracker.cxx:1616
 AliTPCtracker.cxx:1617
 AliTPCtracker.cxx:1618
 AliTPCtracker.cxx:1619
 AliTPCtracker.cxx:1620
 AliTPCtracker.cxx:1621
 AliTPCtracker.cxx:1622
 AliTPCtracker.cxx:1623
 AliTPCtracker.cxx:1624
 AliTPCtracker.cxx:1625
 AliTPCtracker.cxx:1626
 AliTPCtracker.cxx:1627
 AliTPCtracker.cxx:1628
 AliTPCtracker.cxx:1629
 AliTPCtracker.cxx:1630
 AliTPCtracker.cxx:1631
 AliTPCtracker.cxx:1632
 AliTPCtracker.cxx:1633
 AliTPCtracker.cxx:1634
 AliTPCtracker.cxx:1635
 AliTPCtracker.cxx:1636
 AliTPCtracker.cxx:1637
 AliTPCtracker.cxx:1638
 AliTPCtracker.cxx:1639
 AliTPCtracker.cxx:1640
 AliTPCtracker.cxx:1641
 AliTPCtracker.cxx:1642
 AliTPCtracker.cxx:1643
 AliTPCtracker.cxx:1644
 AliTPCtracker.cxx:1645
 AliTPCtracker.cxx:1646
 AliTPCtracker.cxx:1647
 AliTPCtracker.cxx:1648
 AliTPCtracker.cxx:1649
 AliTPCtracker.cxx:1650
 AliTPCtracker.cxx:1651
 AliTPCtracker.cxx:1652
 AliTPCtracker.cxx:1653
 AliTPCtracker.cxx:1654
 AliTPCtracker.cxx:1655
 AliTPCtracker.cxx:1656
 AliTPCtracker.cxx:1657
 AliTPCtracker.cxx:1658
 AliTPCtracker.cxx:1659
 AliTPCtracker.cxx:1660
 AliTPCtracker.cxx:1661
 AliTPCtracker.cxx:1662
 AliTPCtracker.cxx:1663
 AliTPCtracker.cxx:1664
 AliTPCtracker.cxx:1665
 AliTPCtracker.cxx:1666
 AliTPCtracker.cxx:1667
 AliTPCtracker.cxx:1668
 AliTPCtracker.cxx:1669
 AliTPCtracker.cxx:1670
 AliTPCtracker.cxx:1671
 AliTPCtracker.cxx:1672
 AliTPCtracker.cxx:1673
 AliTPCtracker.cxx:1674
 AliTPCtracker.cxx:1675
 AliTPCtracker.cxx:1676
 AliTPCtracker.cxx:1677
 AliTPCtracker.cxx:1678
 AliTPCtracker.cxx:1679
 AliTPCtracker.cxx:1680
 AliTPCtracker.cxx:1681
 AliTPCtracker.cxx:1682
 AliTPCtracker.cxx:1683
 AliTPCtracker.cxx:1684
 AliTPCtracker.cxx:1685
 AliTPCtracker.cxx:1686
 AliTPCtracker.cxx:1687
 AliTPCtracker.cxx:1688
 AliTPCtracker.cxx:1689
 AliTPCtracker.cxx:1690
 AliTPCtracker.cxx:1691
 AliTPCtracker.cxx:1692
 AliTPCtracker.cxx:1693
 AliTPCtracker.cxx:1694
 AliTPCtracker.cxx:1695
 AliTPCtracker.cxx:1696
 AliTPCtracker.cxx:1697
 AliTPCtracker.cxx:1698
 AliTPCtracker.cxx:1699
 AliTPCtracker.cxx:1700
 AliTPCtracker.cxx:1701
 AliTPCtracker.cxx:1702
 AliTPCtracker.cxx:1703
 AliTPCtracker.cxx:1704
 AliTPCtracker.cxx:1705
 AliTPCtracker.cxx:1706
 AliTPCtracker.cxx:1707
 AliTPCtracker.cxx:1708
 AliTPCtracker.cxx:1709
 AliTPCtracker.cxx:1710
 AliTPCtracker.cxx:1711
 AliTPCtracker.cxx:1712
 AliTPCtracker.cxx:1713
 AliTPCtracker.cxx:1714
 AliTPCtracker.cxx:1715
 AliTPCtracker.cxx:1716
 AliTPCtracker.cxx:1717
 AliTPCtracker.cxx:1718
 AliTPCtracker.cxx:1719
 AliTPCtracker.cxx:1720
 AliTPCtracker.cxx:1721
 AliTPCtracker.cxx:1722
 AliTPCtracker.cxx:1723
 AliTPCtracker.cxx:1724
 AliTPCtracker.cxx:1725
 AliTPCtracker.cxx:1726
 AliTPCtracker.cxx:1727
 AliTPCtracker.cxx:1728
 AliTPCtracker.cxx:1729
 AliTPCtracker.cxx:1730
 AliTPCtracker.cxx:1731
 AliTPCtracker.cxx:1732
 AliTPCtracker.cxx:1733
 AliTPCtracker.cxx:1734
 AliTPCtracker.cxx:1735
 AliTPCtracker.cxx:1736
 AliTPCtracker.cxx:1737
 AliTPCtracker.cxx:1738
 AliTPCtracker.cxx:1739
 AliTPCtracker.cxx:1740
 AliTPCtracker.cxx:1741
 AliTPCtracker.cxx:1742
 AliTPCtracker.cxx:1743
 AliTPCtracker.cxx:1744
 AliTPCtracker.cxx:1745
 AliTPCtracker.cxx:1746
 AliTPCtracker.cxx:1747
 AliTPCtracker.cxx:1748
 AliTPCtracker.cxx:1749
 AliTPCtracker.cxx:1750
 AliTPCtracker.cxx:1751
 AliTPCtracker.cxx:1752
 AliTPCtracker.cxx:1753
 AliTPCtracker.cxx:1754
 AliTPCtracker.cxx:1755
 AliTPCtracker.cxx:1756
 AliTPCtracker.cxx:1757
 AliTPCtracker.cxx:1758
 AliTPCtracker.cxx:1759
 AliTPCtracker.cxx:1760
 AliTPCtracker.cxx:1761
 AliTPCtracker.cxx:1762
 AliTPCtracker.cxx:1763
 AliTPCtracker.cxx:1764
 AliTPCtracker.cxx:1765
 AliTPCtracker.cxx:1766
 AliTPCtracker.cxx:1767
 AliTPCtracker.cxx:1768
 AliTPCtracker.cxx:1769
 AliTPCtracker.cxx:1770
 AliTPCtracker.cxx:1771
 AliTPCtracker.cxx:1772
 AliTPCtracker.cxx:1773
 AliTPCtracker.cxx:1774
 AliTPCtracker.cxx:1775
 AliTPCtracker.cxx:1776
 AliTPCtracker.cxx:1777
 AliTPCtracker.cxx:1778
 AliTPCtracker.cxx:1779
 AliTPCtracker.cxx:1780
 AliTPCtracker.cxx:1781
 AliTPCtracker.cxx:1782
 AliTPCtracker.cxx:1783
 AliTPCtracker.cxx:1784
 AliTPCtracker.cxx:1785
 AliTPCtracker.cxx:1786
 AliTPCtracker.cxx:1787
 AliTPCtracker.cxx:1788
 AliTPCtracker.cxx:1789
 AliTPCtracker.cxx:1790
 AliTPCtracker.cxx:1791
 AliTPCtracker.cxx:1792
 AliTPCtracker.cxx:1793
 AliTPCtracker.cxx:1794
 AliTPCtracker.cxx:1795
 AliTPCtracker.cxx:1796
 AliTPCtracker.cxx:1797
 AliTPCtracker.cxx:1798
 AliTPCtracker.cxx:1799
 AliTPCtracker.cxx:1800
 AliTPCtracker.cxx:1801
 AliTPCtracker.cxx:1802
 AliTPCtracker.cxx:1803
 AliTPCtracker.cxx:1804
 AliTPCtracker.cxx:1805
 AliTPCtracker.cxx:1806
 AliTPCtracker.cxx:1807
 AliTPCtracker.cxx:1808
 AliTPCtracker.cxx:1809
 AliTPCtracker.cxx:1810
 AliTPCtracker.cxx:1811
 AliTPCtracker.cxx:1812
 AliTPCtracker.cxx:1813
 AliTPCtracker.cxx:1814
 AliTPCtracker.cxx:1815
 AliTPCtracker.cxx:1816
 AliTPCtracker.cxx:1817
 AliTPCtracker.cxx:1818
 AliTPCtracker.cxx:1819
 AliTPCtracker.cxx:1820
 AliTPCtracker.cxx:1821
 AliTPCtracker.cxx:1822
 AliTPCtracker.cxx:1823
 AliTPCtracker.cxx:1824
 AliTPCtracker.cxx:1825
 AliTPCtracker.cxx:1826
 AliTPCtracker.cxx:1827
 AliTPCtracker.cxx:1828
 AliTPCtracker.cxx:1829
 AliTPCtracker.cxx:1830
 AliTPCtracker.cxx:1831
 AliTPCtracker.cxx:1832
 AliTPCtracker.cxx:1833
 AliTPCtracker.cxx:1834
 AliTPCtracker.cxx:1835
 AliTPCtracker.cxx:1836
 AliTPCtracker.cxx:1837
 AliTPCtracker.cxx:1838
 AliTPCtracker.cxx:1839
 AliTPCtracker.cxx:1840
 AliTPCtracker.cxx:1841
 AliTPCtracker.cxx:1842
 AliTPCtracker.cxx:1843
 AliTPCtracker.cxx:1844
 AliTPCtracker.cxx:1845
 AliTPCtracker.cxx:1846
 AliTPCtracker.cxx:1847
 AliTPCtracker.cxx:1848
 AliTPCtracker.cxx:1849
 AliTPCtracker.cxx:1850
 AliTPCtracker.cxx:1851
 AliTPCtracker.cxx:1852
 AliTPCtracker.cxx:1853
 AliTPCtracker.cxx:1854
 AliTPCtracker.cxx:1855
 AliTPCtracker.cxx:1856
 AliTPCtracker.cxx:1857
 AliTPCtracker.cxx:1858
 AliTPCtracker.cxx:1859
 AliTPCtracker.cxx:1860
 AliTPCtracker.cxx:1861
 AliTPCtracker.cxx:1862
 AliTPCtracker.cxx:1863
 AliTPCtracker.cxx:1864
 AliTPCtracker.cxx:1865
 AliTPCtracker.cxx:1866
 AliTPCtracker.cxx:1867
 AliTPCtracker.cxx:1868
 AliTPCtracker.cxx:1869
 AliTPCtracker.cxx:1870
 AliTPCtracker.cxx:1871
 AliTPCtracker.cxx:1872
 AliTPCtracker.cxx:1873
 AliTPCtracker.cxx:1874
 AliTPCtracker.cxx:1875
 AliTPCtracker.cxx:1876
 AliTPCtracker.cxx:1877
 AliTPCtracker.cxx:1878
 AliTPCtracker.cxx:1879
 AliTPCtracker.cxx:1880
 AliTPCtracker.cxx:1881
 AliTPCtracker.cxx:1882
 AliTPCtracker.cxx:1883
 AliTPCtracker.cxx:1884
 AliTPCtracker.cxx:1885
 AliTPCtracker.cxx:1886
 AliTPCtracker.cxx:1887
 AliTPCtracker.cxx:1888
 AliTPCtracker.cxx:1889
 AliTPCtracker.cxx:1890
 AliTPCtracker.cxx:1891
 AliTPCtracker.cxx:1892
 AliTPCtracker.cxx:1893
 AliTPCtracker.cxx:1894
 AliTPCtracker.cxx:1895
 AliTPCtracker.cxx:1896
 AliTPCtracker.cxx:1897
 AliTPCtracker.cxx:1898
 AliTPCtracker.cxx:1899
 AliTPCtracker.cxx:1900
 AliTPCtracker.cxx:1901
 AliTPCtracker.cxx:1902
 AliTPCtracker.cxx:1903
 AliTPCtracker.cxx:1904
 AliTPCtracker.cxx:1905
 AliTPCtracker.cxx:1906
 AliTPCtracker.cxx:1907
 AliTPCtracker.cxx:1908
 AliTPCtracker.cxx:1909
 AliTPCtracker.cxx:1910
 AliTPCtracker.cxx:1911
 AliTPCtracker.cxx:1912
 AliTPCtracker.cxx:1913
 AliTPCtracker.cxx:1914
 AliTPCtracker.cxx:1915
 AliTPCtracker.cxx:1916
 AliTPCtracker.cxx:1917
 AliTPCtracker.cxx:1918
 AliTPCtracker.cxx:1919
 AliTPCtracker.cxx:1920
 AliTPCtracker.cxx:1921
 AliTPCtracker.cxx:1922
 AliTPCtracker.cxx:1923
 AliTPCtracker.cxx:1924
 AliTPCtracker.cxx:1925
 AliTPCtracker.cxx:1926
 AliTPCtracker.cxx:1927
 AliTPCtracker.cxx:1928
 AliTPCtracker.cxx:1929
 AliTPCtracker.cxx:1930
 AliTPCtracker.cxx:1931
 AliTPCtracker.cxx:1932
 AliTPCtracker.cxx:1933
 AliTPCtracker.cxx:1934
 AliTPCtracker.cxx:1935
 AliTPCtracker.cxx:1936
 AliTPCtracker.cxx:1937
 AliTPCtracker.cxx:1938
 AliTPCtracker.cxx:1939
 AliTPCtracker.cxx:1940
 AliTPCtracker.cxx:1941
 AliTPCtracker.cxx:1942
 AliTPCtracker.cxx:1943
 AliTPCtracker.cxx:1944
 AliTPCtracker.cxx:1945
 AliTPCtracker.cxx:1946
 AliTPCtracker.cxx:1947
 AliTPCtracker.cxx:1948
 AliTPCtracker.cxx:1949
 AliTPCtracker.cxx:1950
 AliTPCtracker.cxx:1951
 AliTPCtracker.cxx:1952
 AliTPCtracker.cxx:1953
 AliTPCtracker.cxx:1954
 AliTPCtracker.cxx:1955
 AliTPCtracker.cxx:1956
 AliTPCtracker.cxx:1957
 AliTPCtracker.cxx:1958
 AliTPCtracker.cxx:1959
 AliTPCtracker.cxx:1960
 AliTPCtracker.cxx:1961
 AliTPCtracker.cxx:1962
 AliTPCtracker.cxx:1963
 AliTPCtracker.cxx:1964
 AliTPCtracker.cxx:1965
 AliTPCtracker.cxx:1966
 AliTPCtracker.cxx:1967
 AliTPCtracker.cxx:1968
 AliTPCtracker.cxx:1969
 AliTPCtracker.cxx:1970
 AliTPCtracker.cxx:1971
 AliTPCtracker.cxx:1972
 AliTPCtracker.cxx:1973
 AliTPCtracker.cxx:1974
 AliTPCtracker.cxx:1975
 AliTPCtracker.cxx:1976
 AliTPCtracker.cxx:1977
 AliTPCtracker.cxx:1978
 AliTPCtracker.cxx:1979
 AliTPCtracker.cxx:1980
 AliTPCtracker.cxx:1981
 AliTPCtracker.cxx:1982
 AliTPCtracker.cxx:1983
 AliTPCtracker.cxx:1984
 AliTPCtracker.cxx:1985
 AliTPCtracker.cxx:1986
 AliTPCtracker.cxx:1987
 AliTPCtracker.cxx:1988
 AliTPCtracker.cxx:1989
 AliTPCtracker.cxx:1990
 AliTPCtracker.cxx:1991
 AliTPCtracker.cxx:1992
 AliTPCtracker.cxx:1993
 AliTPCtracker.cxx:1994
 AliTPCtracker.cxx:1995
 AliTPCtracker.cxx:1996
 AliTPCtracker.cxx:1997
 AliTPCtracker.cxx:1998
 AliTPCtracker.cxx:1999
 AliTPCtracker.cxx:2000
 AliTPCtracker.cxx:2001
 AliTPCtracker.cxx:2002
 AliTPCtracker.cxx:2003
 AliTPCtracker.cxx:2004
 AliTPCtracker.cxx:2005
 AliTPCtracker.cxx:2006
 AliTPCtracker.cxx:2007
 AliTPCtracker.cxx:2008
 AliTPCtracker.cxx:2009
 AliTPCtracker.cxx:2010
 AliTPCtracker.cxx:2011
 AliTPCtracker.cxx:2012
 AliTPCtracker.cxx:2013
 AliTPCtracker.cxx:2014
 AliTPCtracker.cxx:2015
 AliTPCtracker.cxx:2016
 AliTPCtracker.cxx:2017
 AliTPCtracker.cxx:2018
 AliTPCtracker.cxx:2019
 AliTPCtracker.cxx:2020
 AliTPCtracker.cxx:2021
 AliTPCtracker.cxx:2022
 AliTPCtracker.cxx:2023
 AliTPCtracker.cxx:2024
 AliTPCtracker.cxx:2025
 AliTPCtracker.cxx:2026
 AliTPCtracker.cxx:2027
 AliTPCtracker.cxx:2028
 AliTPCtracker.cxx:2029
 AliTPCtracker.cxx:2030
 AliTPCtracker.cxx:2031
 AliTPCtracker.cxx:2032
 AliTPCtracker.cxx:2033
 AliTPCtracker.cxx:2034
 AliTPCtracker.cxx:2035
 AliTPCtracker.cxx:2036
 AliTPCtracker.cxx:2037
 AliTPCtracker.cxx:2038
 AliTPCtracker.cxx:2039
 AliTPCtracker.cxx:2040
 AliTPCtracker.cxx:2041
 AliTPCtracker.cxx:2042
 AliTPCtracker.cxx:2043
 AliTPCtracker.cxx:2044
 AliTPCtracker.cxx:2045
 AliTPCtracker.cxx:2046
 AliTPCtracker.cxx:2047
 AliTPCtracker.cxx:2048
 AliTPCtracker.cxx:2049
 AliTPCtracker.cxx:2050
 AliTPCtracker.cxx:2051
 AliTPCtracker.cxx:2052
 AliTPCtracker.cxx:2053
 AliTPCtracker.cxx:2054
 AliTPCtracker.cxx:2055
 AliTPCtracker.cxx:2056
 AliTPCtracker.cxx:2057
 AliTPCtracker.cxx:2058
 AliTPCtracker.cxx:2059
 AliTPCtracker.cxx:2060
 AliTPCtracker.cxx:2061
 AliTPCtracker.cxx:2062
 AliTPCtracker.cxx:2063
 AliTPCtracker.cxx:2064
 AliTPCtracker.cxx:2065
 AliTPCtracker.cxx:2066
 AliTPCtracker.cxx:2067
 AliTPCtracker.cxx:2068
 AliTPCtracker.cxx:2069
 AliTPCtracker.cxx:2070
 AliTPCtracker.cxx:2071
 AliTPCtracker.cxx:2072
 AliTPCtracker.cxx:2073
 AliTPCtracker.cxx:2074
 AliTPCtracker.cxx:2075
 AliTPCtracker.cxx:2076
 AliTPCtracker.cxx:2077
 AliTPCtracker.cxx:2078
 AliTPCtracker.cxx:2079
 AliTPCtracker.cxx:2080
 AliTPCtracker.cxx:2081
 AliTPCtracker.cxx:2082
 AliTPCtracker.cxx:2083
 AliTPCtracker.cxx:2084
 AliTPCtracker.cxx:2085
 AliTPCtracker.cxx:2086
 AliTPCtracker.cxx:2087
 AliTPCtracker.cxx:2088
 AliTPCtracker.cxx:2089
 AliTPCtracker.cxx:2090
 AliTPCtracker.cxx:2091
 AliTPCtracker.cxx:2092
 AliTPCtracker.cxx:2093
 AliTPCtracker.cxx:2094
 AliTPCtracker.cxx:2095
 AliTPCtracker.cxx:2096
 AliTPCtracker.cxx:2097
 AliTPCtracker.cxx:2098
 AliTPCtracker.cxx:2099
 AliTPCtracker.cxx:2100
 AliTPCtracker.cxx:2101
 AliTPCtracker.cxx:2102
 AliTPCtracker.cxx:2103
 AliTPCtracker.cxx:2104
 AliTPCtracker.cxx:2105
 AliTPCtracker.cxx:2106
 AliTPCtracker.cxx:2107
 AliTPCtracker.cxx:2108
 AliTPCtracker.cxx:2109
 AliTPCtracker.cxx:2110
 AliTPCtracker.cxx:2111
 AliTPCtracker.cxx:2112
 AliTPCtracker.cxx:2113
 AliTPCtracker.cxx:2114
 AliTPCtracker.cxx:2115
 AliTPCtracker.cxx:2116
 AliTPCtracker.cxx:2117
 AliTPCtracker.cxx:2118
 AliTPCtracker.cxx:2119
 AliTPCtracker.cxx:2120
 AliTPCtracker.cxx:2121
 AliTPCtracker.cxx:2122
 AliTPCtracker.cxx:2123
 AliTPCtracker.cxx:2124
 AliTPCtracker.cxx:2125
 AliTPCtracker.cxx:2126
 AliTPCtracker.cxx:2127
 AliTPCtracker.cxx:2128
 AliTPCtracker.cxx:2129
 AliTPCtracker.cxx:2130
 AliTPCtracker.cxx:2131
 AliTPCtracker.cxx:2132
 AliTPCtracker.cxx:2133
 AliTPCtracker.cxx:2134
 AliTPCtracker.cxx:2135
 AliTPCtracker.cxx:2136
 AliTPCtracker.cxx:2137
 AliTPCtracker.cxx:2138
 AliTPCtracker.cxx:2139
 AliTPCtracker.cxx:2140
 AliTPCtracker.cxx:2141
 AliTPCtracker.cxx:2142
 AliTPCtracker.cxx:2143
 AliTPCtracker.cxx:2144
 AliTPCtracker.cxx:2145
 AliTPCtracker.cxx:2146
 AliTPCtracker.cxx:2147
 AliTPCtracker.cxx:2148
 AliTPCtracker.cxx:2149
 AliTPCtracker.cxx:2150
 AliTPCtracker.cxx:2151
 AliTPCtracker.cxx:2152
 AliTPCtracker.cxx:2153
 AliTPCtracker.cxx:2154
 AliTPCtracker.cxx:2155
 AliTPCtracker.cxx:2156
 AliTPCtracker.cxx:2157
 AliTPCtracker.cxx:2158
 AliTPCtracker.cxx:2159
 AliTPCtracker.cxx:2160
 AliTPCtracker.cxx:2161
 AliTPCtracker.cxx:2162
 AliTPCtracker.cxx:2163
 AliTPCtracker.cxx:2164
 AliTPCtracker.cxx:2165
 AliTPCtracker.cxx:2166
 AliTPCtracker.cxx:2167
 AliTPCtracker.cxx:2168
 AliTPCtracker.cxx:2169
 AliTPCtracker.cxx:2170
 AliTPCtracker.cxx:2171
 AliTPCtracker.cxx:2172
 AliTPCtracker.cxx:2173
 AliTPCtracker.cxx:2174
 AliTPCtracker.cxx:2175
 AliTPCtracker.cxx:2176
 AliTPCtracker.cxx:2177
 AliTPCtracker.cxx:2178
 AliTPCtracker.cxx:2179
 AliTPCtracker.cxx:2180
 AliTPCtracker.cxx:2181
 AliTPCtracker.cxx:2182
 AliTPCtracker.cxx:2183
 AliTPCtracker.cxx:2184
 AliTPCtracker.cxx:2185
 AliTPCtracker.cxx:2186
 AliTPCtracker.cxx:2187
 AliTPCtracker.cxx:2188
 AliTPCtracker.cxx:2189
 AliTPCtracker.cxx:2190
 AliTPCtracker.cxx:2191
 AliTPCtracker.cxx:2192
 AliTPCtracker.cxx:2193
 AliTPCtracker.cxx:2194
 AliTPCtracker.cxx:2195
 AliTPCtracker.cxx:2196
 AliTPCtracker.cxx:2197
 AliTPCtracker.cxx:2198
 AliTPCtracker.cxx:2199
 AliTPCtracker.cxx:2200
 AliTPCtracker.cxx:2201
 AliTPCtracker.cxx:2202
 AliTPCtracker.cxx:2203
 AliTPCtracker.cxx:2204
 AliTPCtracker.cxx:2205
 AliTPCtracker.cxx:2206
 AliTPCtracker.cxx:2207
 AliTPCtracker.cxx:2208
 AliTPCtracker.cxx:2209
 AliTPCtracker.cxx:2210
 AliTPCtracker.cxx:2211
 AliTPCtracker.cxx:2212
 AliTPCtracker.cxx:2213
 AliTPCtracker.cxx:2214
 AliTPCtracker.cxx:2215
 AliTPCtracker.cxx:2216
 AliTPCtracker.cxx:2217
 AliTPCtracker.cxx:2218
 AliTPCtracker.cxx:2219
 AliTPCtracker.cxx:2220
 AliTPCtracker.cxx:2221
 AliTPCtracker.cxx:2222
 AliTPCtracker.cxx:2223
 AliTPCtracker.cxx:2224
 AliTPCtracker.cxx:2225
 AliTPCtracker.cxx:2226
 AliTPCtracker.cxx:2227
 AliTPCtracker.cxx:2228
 AliTPCtracker.cxx:2229
 AliTPCtracker.cxx:2230
 AliTPCtracker.cxx:2231
 AliTPCtracker.cxx:2232
 AliTPCtracker.cxx:2233
 AliTPCtracker.cxx:2234
 AliTPCtracker.cxx:2235
 AliTPCtracker.cxx:2236
 AliTPCtracker.cxx:2237
 AliTPCtracker.cxx:2238
 AliTPCtracker.cxx:2239
 AliTPCtracker.cxx:2240
 AliTPCtracker.cxx:2241
 AliTPCtracker.cxx:2242
 AliTPCtracker.cxx:2243
 AliTPCtracker.cxx:2244
 AliTPCtracker.cxx:2245
 AliTPCtracker.cxx:2246
 AliTPCtracker.cxx:2247
 AliTPCtracker.cxx:2248
 AliTPCtracker.cxx:2249
 AliTPCtracker.cxx:2250
 AliTPCtracker.cxx:2251
 AliTPCtracker.cxx:2252
 AliTPCtracker.cxx:2253
 AliTPCtracker.cxx:2254
 AliTPCtracker.cxx:2255
 AliTPCtracker.cxx:2256
 AliTPCtracker.cxx:2257
 AliTPCtracker.cxx:2258
 AliTPCtracker.cxx:2259
 AliTPCtracker.cxx:2260
 AliTPCtracker.cxx:2261
 AliTPCtracker.cxx:2262
 AliTPCtracker.cxx:2263
 AliTPCtracker.cxx:2264
 AliTPCtracker.cxx:2265
 AliTPCtracker.cxx:2266
 AliTPCtracker.cxx:2267
 AliTPCtracker.cxx:2268
 AliTPCtracker.cxx:2269
 AliTPCtracker.cxx:2270
 AliTPCtracker.cxx:2271
 AliTPCtracker.cxx:2272
 AliTPCtracker.cxx:2273
 AliTPCtracker.cxx:2274
 AliTPCtracker.cxx:2275
 AliTPCtracker.cxx:2276
 AliTPCtracker.cxx:2277
 AliTPCtracker.cxx:2278
 AliTPCtracker.cxx:2279
 AliTPCtracker.cxx:2280
 AliTPCtracker.cxx:2281
 AliTPCtracker.cxx:2282
 AliTPCtracker.cxx:2283
 AliTPCtracker.cxx:2284
 AliTPCtracker.cxx:2285
 AliTPCtracker.cxx:2286
 AliTPCtracker.cxx:2287
 AliTPCtracker.cxx:2288
 AliTPCtracker.cxx:2289
 AliTPCtracker.cxx:2290
 AliTPCtracker.cxx:2291
 AliTPCtracker.cxx:2292
 AliTPCtracker.cxx:2293
 AliTPCtracker.cxx:2294
 AliTPCtracker.cxx:2295
 AliTPCtracker.cxx:2296
 AliTPCtracker.cxx:2297
 AliTPCtracker.cxx:2298
 AliTPCtracker.cxx:2299
 AliTPCtracker.cxx:2300
 AliTPCtracker.cxx:2301
 AliTPCtracker.cxx:2302
 AliTPCtracker.cxx:2303
 AliTPCtracker.cxx:2304
 AliTPCtracker.cxx:2305
 AliTPCtracker.cxx:2306
 AliTPCtracker.cxx:2307
 AliTPCtracker.cxx:2308
 AliTPCtracker.cxx:2309
 AliTPCtracker.cxx:2310
 AliTPCtracker.cxx:2311
 AliTPCtracker.cxx:2312
 AliTPCtracker.cxx:2313
 AliTPCtracker.cxx:2314
 AliTPCtracker.cxx:2315
 AliTPCtracker.cxx:2316
 AliTPCtracker.cxx:2317
 AliTPCtracker.cxx:2318
 AliTPCtracker.cxx:2319
 AliTPCtracker.cxx:2320
 AliTPCtracker.cxx:2321
 AliTPCtracker.cxx:2322
 AliTPCtracker.cxx:2323
 AliTPCtracker.cxx:2324
 AliTPCtracker.cxx:2325
 AliTPCtracker.cxx:2326
 AliTPCtracker.cxx:2327
 AliTPCtracker.cxx:2328
 AliTPCtracker.cxx:2329
 AliTPCtracker.cxx:2330
 AliTPCtracker.cxx:2331
 AliTPCtracker.cxx:2332
 AliTPCtracker.cxx:2333
 AliTPCtracker.cxx:2334
 AliTPCtracker.cxx:2335
 AliTPCtracker.cxx:2336
 AliTPCtracker.cxx:2337
 AliTPCtracker.cxx:2338
 AliTPCtracker.cxx:2339
 AliTPCtracker.cxx:2340
 AliTPCtracker.cxx:2341
 AliTPCtracker.cxx:2342
 AliTPCtracker.cxx:2343
 AliTPCtracker.cxx:2344
 AliTPCtracker.cxx:2345
 AliTPCtracker.cxx:2346
 AliTPCtracker.cxx:2347
 AliTPCtracker.cxx:2348
 AliTPCtracker.cxx:2349
 AliTPCtracker.cxx:2350
 AliTPCtracker.cxx:2351
 AliTPCtracker.cxx:2352
 AliTPCtracker.cxx:2353
 AliTPCtracker.cxx:2354
 AliTPCtracker.cxx:2355
 AliTPCtracker.cxx:2356
 AliTPCtracker.cxx:2357
 AliTPCtracker.cxx:2358
 AliTPCtracker.cxx:2359
 AliTPCtracker.cxx:2360
 AliTPCtracker.cxx:2361
 AliTPCtracker.cxx:2362
 AliTPCtracker.cxx:2363
 AliTPCtracker.cxx:2364
 AliTPCtracker.cxx:2365
 AliTPCtracker.cxx:2366
 AliTPCtracker.cxx:2367
 AliTPCtracker.cxx:2368
 AliTPCtracker.cxx:2369
 AliTPCtracker.cxx:2370
 AliTPCtracker.cxx:2371
 AliTPCtracker.cxx:2372
 AliTPCtracker.cxx:2373
 AliTPCtracker.cxx:2374
 AliTPCtracker.cxx:2375
 AliTPCtracker.cxx:2376
 AliTPCtracker.cxx:2377
 AliTPCtracker.cxx:2378
 AliTPCtracker.cxx:2379
 AliTPCtracker.cxx:2380
 AliTPCtracker.cxx:2381
 AliTPCtracker.cxx:2382
 AliTPCtracker.cxx:2383
 AliTPCtracker.cxx:2384
 AliTPCtracker.cxx:2385
 AliTPCtracker.cxx:2386
 AliTPCtracker.cxx:2387
 AliTPCtracker.cxx:2388
 AliTPCtracker.cxx:2389
 AliTPCtracker.cxx:2390
 AliTPCtracker.cxx:2391
 AliTPCtracker.cxx:2392
 AliTPCtracker.cxx:2393
 AliTPCtracker.cxx:2394
 AliTPCtracker.cxx:2395
 AliTPCtracker.cxx:2396
 AliTPCtracker.cxx:2397
 AliTPCtracker.cxx:2398
 AliTPCtracker.cxx:2399
 AliTPCtracker.cxx:2400
 AliTPCtracker.cxx:2401
 AliTPCtracker.cxx:2402
 AliTPCtracker.cxx:2403
 AliTPCtracker.cxx:2404
 AliTPCtracker.cxx:2405
 AliTPCtracker.cxx:2406
 AliTPCtracker.cxx:2407
 AliTPCtracker.cxx:2408
 AliTPCtracker.cxx:2409
 AliTPCtracker.cxx:2410
 AliTPCtracker.cxx:2411
 AliTPCtracker.cxx:2412
 AliTPCtracker.cxx:2413
 AliTPCtracker.cxx:2414
 AliTPCtracker.cxx:2415
 AliTPCtracker.cxx:2416
 AliTPCtracker.cxx:2417
 AliTPCtracker.cxx:2418
 AliTPCtracker.cxx:2419
 AliTPCtracker.cxx:2420
 AliTPCtracker.cxx:2421
 AliTPCtracker.cxx:2422
 AliTPCtracker.cxx:2423
 AliTPCtracker.cxx:2424
 AliTPCtracker.cxx:2425
 AliTPCtracker.cxx:2426
 AliTPCtracker.cxx:2427
 AliTPCtracker.cxx:2428
 AliTPCtracker.cxx:2429
 AliTPCtracker.cxx:2430
 AliTPCtracker.cxx:2431
 AliTPCtracker.cxx:2432
 AliTPCtracker.cxx:2433
 AliTPCtracker.cxx:2434
 AliTPCtracker.cxx:2435
 AliTPCtracker.cxx:2436
 AliTPCtracker.cxx:2437
 AliTPCtracker.cxx:2438
 AliTPCtracker.cxx:2439
 AliTPCtracker.cxx:2440
 AliTPCtracker.cxx:2441
 AliTPCtracker.cxx:2442
 AliTPCtracker.cxx:2443
 AliTPCtracker.cxx:2444
 AliTPCtracker.cxx:2445
 AliTPCtracker.cxx:2446
 AliTPCtracker.cxx:2447
 AliTPCtracker.cxx:2448
 AliTPCtracker.cxx:2449
 AliTPCtracker.cxx:2450
 AliTPCtracker.cxx:2451
 AliTPCtracker.cxx:2452
 AliTPCtracker.cxx:2453
 AliTPCtracker.cxx:2454
 AliTPCtracker.cxx:2455
 AliTPCtracker.cxx:2456
 AliTPCtracker.cxx:2457
 AliTPCtracker.cxx:2458
 AliTPCtracker.cxx:2459
 AliTPCtracker.cxx:2460
 AliTPCtracker.cxx:2461
 AliTPCtracker.cxx:2462
 AliTPCtracker.cxx:2463
 AliTPCtracker.cxx:2464
 AliTPCtracker.cxx:2465
 AliTPCtracker.cxx:2466
 AliTPCtracker.cxx:2467
 AliTPCtracker.cxx:2468
 AliTPCtracker.cxx:2469
 AliTPCtracker.cxx:2470
 AliTPCtracker.cxx:2471
 AliTPCtracker.cxx:2472
 AliTPCtracker.cxx:2473
 AliTPCtracker.cxx:2474
 AliTPCtracker.cxx:2475
 AliTPCtracker.cxx:2476
 AliTPCtracker.cxx:2477
 AliTPCtracker.cxx:2478
 AliTPCtracker.cxx:2479
 AliTPCtracker.cxx:2480
 AliTPCtracker.cxx:2481
 AliTPCtracker.cxx:2482
 AliTPCtracker.cxx:2483
 AliTPCtracker.cxx:2484
 AliTPCtracker.cxx:2485
 AliTPCtracker.cxx:2486
 AliTPCtracker.cxx:2487
 AliTPCtracker.cxx:2488
 AliTPCtracker.cxx:2489
 AliTPCtracker.cxx:2490
 AliTPCtracker.cxx:2491
 AliTPCtracker.cxx:2492
 AliTPCtracker.cxx:2493
 AliTPCtracker.cxx:2494
 AliTPCtracker.cxx:2495
 AliTPCtracker.cxx:2496
 AliTPCtracker.cxx:2497
 AliTPCtracker.cxx:2498
 AliTPCtracker.cxx:2499
 AliTPCtracker.cxx:2500
 AliTPCtracker.cxx:2501
 AliTPCtracker.cxx:2502
 AliTPCtracker.cxx:2503
 AliTPCtracker.cxx:2504
 AliTPCtracker.cxx:2505
 AliTPCtracker.cxx:2506
 AliTPCtracker.cxx:2507
 AliTPCtracker.cxx:2508
 AliTPCtracker.cxx:2509
 AliTPCtracker.cxx:2510
 AliTPCtracker.cxx:2511
 AliTPCtracker.cxx:2512
 AliTPCtracker.cxx:2513
 AliTPCtracker.cxx:2514
 AliTPCtracker.cxx:2515
 AliTPCtracker.cxx:2516
 AliTPCtracker.cxx:2517
 AliTPCtracker.cxx:2518
 AliTPCtracker.cxx:2519
 AliTPCtracker.cxx:2520
 AliTPCtracker.cxx:2521
 AliTPCtracker.cxx:2522
 AliTPCtracker.cxx:2523
 AliTPCtracker.cxx:2524
 AliTPCtracker.cxx:2525
 AliTPCtracker.cxx:2526
 AliTPCtracker.cxx:2527
 AliTPCtracker.cxx:2528
 AliTPCtracker.cxx:2529
 AliTPCtracker.cxx:2530
 AliTPCtracker.cxx:2531
 AliTPCtracker.cxx:2532
 AliTPCtracker.cxx:2533
 AliTPCtracker.cxx:2534
 AliTPCtracker.cxx:2535
 AliTPCtracker.cxx:2536
 AliTPCtracker.cxx:2537
 AliTPCtracker.cxx:2538
 AliTPCtracker.cxx:2539
 AliTPCtracker.cxx:2540
 AliTPCtracker.cxx:2541
 AliTPCtracker.cxx:2542
 AliTPCtracker.cxx:2543
 AliTPCtracker.cxx:2544
 AliTPCtracker.cxx:2545
 AliTPCtracker.cxx:2546
 AliTPCtracker.cxx:2547
 AliTPCtracker.cxx:2548
 AliTPCtracker.cxx:2549
 AliTPCtracker.cxx:2550
 AliTPCtracker.cxx:2551
 AliTPCtracker.cxx:2552
 AliTPCtracker.cxx:2553
 AliTPCtracker.cxx:2554
 AliTPCtracker.cxx:2555
 AliTPCtracker.cxx:2556
 AliTPCtracker.cxx:2557
 AliTPCtracker.cxx:2558
 AliTPCtracker.cxx:2559
 AliTPCtracker.cxx:2560
 AliTPCtracker.cxx:2561
 AliTPCtracker.cxx:2562
 AliTPCtracker.cxx:2563
 AliTPCtracker.cxx:2564
 AliTPCtracker.cxx:2565
 AliTPCtracker.cxx:2566
 AliTPCtracker.cxx:2567
 AliTPCtracker.cxx:2568
 AliTPCtracker.cxx:2569
 AliTPCtracker.cxx:2570
 AliTPCtracker.cxx:2571
 AliTPCtracker.cxx:2572
 AliTPCtracker.cxx:2573
 AliTPCtracker.cxx:2574
 AliTPCtracker.cxx:2575
 AliTPCtracker.cxx:2576
 AliTPCtracker.cxx:2577
 AliTPCtracker.cxx:2578
 AliTPCtracker.cxx:2579
 AliTPCtracker.cxx:2580
 AliTPCtracker.cxx:2581
 AliTPCtracker.cxx:2582
 AliTPCtracker.cxx:2583
 AliTPCtracker.cxx:2584
 AliTPCtracker.cxx:2585
 AliTPCtracker.cxx:2586
 AliTPCtracker.cxx:2587
 AliTPCtracker.cxx:2588
 AliTPCtracker.cxx:2589
 AliTPCtracker.cxx:2590
 AliTPCtracker.cxx:2591
 AliTPCtracker.cxx:2592
 AliTPCtracker.cxx:2593
 AliTPCtracker.cxx:2594
 AliTPCtracker.cxx:2595
 AliTPCtracker.cxx:2596
 AliTPCtracker.cxx:2597
 AliTPCtracker.cxx:2598
 AliTPCtracker.cxx:2599
 AliTPCtracker.cxx:2600
 AliTPCtracker.cxx:2601
 AliTPCtracker.cxx:2602
 AliTPCtracker.cxx:2603
 AliTPCtracker.cxx:2604
 AliTPCtracker.cxx:2605
 AliTPCtracker.cxx:2606
 AliTPCtracker.cxx:2607
 AliTPCtracker.cxx:2608
 AliTPCtracker.cxx:2609
 AliTPCtracker.cxx:2610
 AliTPCtracker.cxx:2611
 AliTPCtracker.cxx:2612
 AliTPCtracker.cxx:2613
 AliTPCtracker.cxx:2614
 AliTPCtracker.cxx:2615
 AliTPCtracker.cxx:2616
 AliTPCtracker.cxx:2617
 AliTPCtracker.cxx:2618
 AliTPCtracker.cxx:2619
 AliTPCtracker.cxx:2620
 AliTPCtracker.cxx:2621
 AliTPCtracker.cxx:2622
 AliTPCtracker.cxx:2623
 AliTPCtracker.cxx:2624
 AliTPCtracker.cxx:2625
 AliTPCtracker.cxx:2626
 AliTPCtracker.cxx:2627
 AliTPCtracker.cxx:2628
 AliTPCtracker.cxx:2629
 AliTPCtracker.cxx:2630
 AliTPCtracker.cxx:2631
 AliTPCtracker.cxx:2632
 AliTPCtracker.cxx:2633
 AliTPCtracker.cxx:2634
 AliTPCtracker.cxx:2635
 AliTPCtracker.cxx:2636
 AliTPCtracker.cxx:2637
 AliTPCtracker.cxx:2638
 AliTPCtracker.cxx:2639
 AliTPCtracker.cxx:2640
 AliTPCtracker.cxx:2641
 AliTPCtracker.cxx:2642
 AliTPCtracker.cxx:2643
 AliTPCtracker.cxx:2644
 AliTPCtracker.cxx:2645
 AliTPCtracker.cxx:2646
 AliTPCtracker.cxx:2647
 AliTPCtracker.cxx:2648
 AliTPCtracker.cxx:2649
 AliTPCtracker.cxx:2650
 AliTPCtracker.cxx:2651
 AliTPCtracker.cxx:2652
 AliTPCtracker.cxx:2653
 AliTPCtracker.cxx:2654
 AliTPCtracker.cxx:2655
 AliTPCtracker.cxx:2656
 AliTPCtracker.cxx:2657
 AliTPCtracker.cxx:2658
 AliTPCtracker.cxx:2659
 AliTPCtracker.cxx:2660
 AliTPCtracker.cxx:2661
 AliTPCtracker.cxx:2662
 AliTPCtracker.cxx:2663
 AliTPCtracker.cxx:2664
 AliTPCtracker.cxx:2665
 AliTPCtracker.cxx:2666
 AliTPCtracker.cxx:2667
 AliTPCtracker.cxx:2668
 AliTPCtracker.cxx:2669
 AliTPCtracker.cxx:2670
 AliTPCtracker.cxx:2671
 AliTPCtracker.cxx:2672
 AliTPCtracker.cxx:2673
 AliTPCtracker.cxx:2674
 AliTPCtracker.cxx:2675
 AliTPCtracker.cxx:2676
 AliTPCtracker.cxx:2677
 AliTPCtracker.cxx:2678
 AliTPCtracker.cxx:2679
 AliTPCtracker.cxx:2680
 AliTPCtracker.cxx:2681
 AliTPCtracker.cxx:2682
 AliTPCtracker.cxx:2683
 AliTPCtracker.cxx:2684
 AliTPCtracker.cxx:2685
 AliTPCtracker.cxx:2686
 AliTPCtracker.cxx:2687
 AliTPCtracker.cxx:2688
 AliTPCtracker.cxx:2689
 AliTPCtracker.cxx:2690
 AliTPCtracker.cxx:2691
 AliTPCtracker.cxx:2692
 AliTPCtracker.cxx:2693
 AliTPCtracker.cxx:2694
 AliTPCtracker.cxx:2695
 AliTPCtracker.cxx:2696
 AliTPCtracker.cxx:2697
 AliTPCtracker.cxx:2698
 AliTPCtracker.cxx:2699
 AliTPCtracker.cxx:2700
 AliTPCtracker.cxx:2701
 AliTPCtracker.cxx:2702
 AliTPCtracker.cxx:2703
 AliTPCtracker.cxx:2704
 AliTPCtracker.cxx:2705
 AliTPCtracker.cxx:2706
 AliTPCtracker.cxx:2707
 AliTPCtracker.cxx:2708
 AliTPCtracker.cxx:2709
 AliTPCtracker.cxx:2710
 AliTPCtracker.cxx:2711
 AliTPCtracker.cxx:2712
 AliTPCtracker.cxx:2713
 AliTPCtracker.cxx:2714
 AliTPCtracker.cxx:2715
 AliTPCtracker.cxx:2716
 AliTPCtracker.cxx:2717
 AliTPCtracker.cxx:2718
 AliTPCtracker.cxx:2719
 AliTPCtracker.cxx:2720
 AliTPCtracker.cxx:2721
 AliTPCtracker.cxx:2722
 AliTPCtracker.cxx:2723
 AliTPCtracker.cxx:2724
 AliTPCtracker.cxx:2725
 AliTPCtracker.cxx:2726
 AliTPCtracker.cxx:2727
 AliTPCtracker.cxx:2728
 AliTPCtracker.cxx:2729
 AliTPCtracker.cxx:2730
 AliTPCtracker.cxx:2731
 AliTPCtracker.cxx:2732
 AliTPCtracker.cxx:2733
 AliTPCtracker.cxx:2734
 AliTPCtracker.cxx:2735
 AliTPCtracker.cxx:2736
 AliTPCtracker.cxx:2737
 AliTPCtracker.cxx:2738
 AliTPCtracker.cxx:2739
 AliTPCtracker.cxx:2740
 AliTPCtracker.cxx:2741
 AliTPCtracker.cxx:2742
 AliTPCtracker.cxx:2743
 AliTPCtracker.cxx:2744
 AliTPCtracker.cxx:2745
 AliTPCtracker.cxx:2746
 AliTPCtracker.cxx:2747
 AliTPCtracker.cxx:2748
 AliTPCtracker.cxx:2749
 AliTPCtracker.cxx:2750
 AliTPCtracker.cxx:2751
 AliTPCtracker.cxx:2752
 AliTPCtracker.cxx:2753
 AliTPCtracker.cxx:2754
 AliTPCtracker.cxx:2755
 AliTPCtracker.cxx:2756
 AliTPCtracker.cxx:2757
 AliTPCtracker.cxx:2758
 AliTPCtracker.cxx:2759
 AliTPCtracker.cxx:2760
 AliTPCtracker.cxx:2761
 AliTPCtracker.cxx:2762
 AliTPCtracker.cxx:2763
 AliTPCtracker.cxx:2764
 AliTPCtracker.cxx:2765
 AliTPCtracker.cxx:2766
 AliTPCtracker.cxx:2767
 AliTPCtracker.cxx:2768
 AliTPCtracker.cxx:2769
 AliTPCtracker.cxx:2770
 AliTPCtracker.cxx:2771
 AliTPCtracker.cxx:2772
 AliTPCtracker.cxx:2773
 AliTPCtracker.cxx:2774
 AliTPCtracker.cxx:2775
 AliTPCtracker.cxx:2776
 AliTPCtracker.cxx:2777
 AliTPCtracker.cxx:2778
 AliTPCtracker.cxx:2779
 AliTPCtracker.cxx:2780
 AliTPCtracker.cxx:2781
 AliTPCtracker.cxx:2782
 AliTPCtracker.cxx:2783
 AliTPCtracker.cxx:2784
 AliTPCtracker.cxx:2785
 AliTPCtracker.cxx:2786
 AliTPCtracker.cxx:2787
 AliTPCtracker.cxx:2788
 AliTPCtracker.cxx:2789
 AliTPCtracker.cxx:2790
 AliTPCtracker.cxx:2791
 AliTPCtracker.cxx:2792
 AliTPCtracker.cxx:2793
 AliTPCtracker.cxx:2794
 AliTPCtracker.cxx:2795
 AliTPCtracker.cxx:2796
 AliTPCtracker.cxx:2797
 AliTPCtracker.cxx:2798
 AliTPCtracker.cxx:2799
 AliTPCtracker.cxx:2800
 AliTPCtracker.cxx:2801
 AliTPCtracker.cxx:2802
 AliTPCtracker.cxx:2803
 AliTPCtracker.cxx:2804
 AliTPCtracker.cxx:2805
 AliTPCtracker.cxx:2806
 AliTPCtracker.cxx:2807
 AliTPCtracker.cxx:2808
 AliTPCtracker.cxx:2809
 AliTPCtracker.cxx:2810
 AliTPCtracker.cxx:2811
 AliTPCtracker.cxx:2812
 AliTPCtracker.cxx:2813
 AliTPCtracker.cxx:2814
 AliTPCtracker.cxx:2815
 AliTPCtracker.cxx:2816
 AliTPCtracker.cxx:2817
 AliTPCtracker.cxx:2818
 AliTPCtracker.cxx:2819
 AliTPCtracker.cxx:2820
 AliTPCtracker.cxx:2821
 AliTPCtracker.cxx:2822
 AliTPCtracker.cxx:2823
 AliTPCtracker.cxx:2824
 AliTPCtracker.cxx:2825
 AliTPCtracker.cxx:2826
 AliTPCtracker.cxx:2827
 AliTPCtracker.cxx:2828
 AliTPCtracker.cxx:2829
 AliTPCtracker.cxx:2830
 AliTPCtracker.cxx:2831
 AliTPCtracker.cxx:2832
 AliTPCtracker.cxx:2833
 AliTPCtracker.cxx:2834
 AliTPCtracker.cxx:2835
 AliTPCtracker.cxx:2836
 AliTPCtracker.cxx:2837
 AliTPCtracker.cxx:2838
 AliTPCtracker.cxx:2839
 AliTPCtracker.cxx:2840
 AliTPCtracker.cxx:2841
 AliTPCtracker.cxx:2842
 AliTPCtracker.cxx:2843
 AliTPCtracker.cxx:2844
 AliTPCtracker.cxx:2845
 AliTPCtracker.cxx:2846
 AliTPCtracker.cxx:2847
 AliTPCtracker.cxx:2848
 AliTPCtracker.cxx:2849
 AliTPCtracker.cxx:2850
 AliTPCtracker.cxx:2851
 AliTPCtracker.cxx:2852
 AliTPCtracker.cxx:2853
 AliTPCtracker.cxx:2854
 AliTPCtracker.cxx:2855
 AliTPCtracker.cxx:2856
 AliTPCtracker.cxx:2857
 AliTPCtracker.cxx:2858
 AliTPCtracker.cxx:2859
 AliTPCtracker.cxx:2860
 AliTPCtracker.cxx:2861
 AliTPCtracker.cxx:2862
 AliTPCtracker.cxx:2863
 AliTPCtracker.cxx:2864
 AliTPCtracker.cxx:2865
 AliTPCtracker.cxx:2866
 AliTPCtracker.cxx:2867
 AliTPCtracker.cxx:2868
 AliTPCtracker.cxx:2869
 AliTPCtracker.cxx:2870
 AliTPCtracker.cxx:2871
 AliTPCtracker.cxx:2872
 AliTPCtracker.cxx:2873
 AliTPCtracker.cxx:2874
 AliTPCtracker.cxx:2875
 AliTPCtracker.cxx:2876
 AliTPCtracker.cxx:2877
 AliTPCtracker.cxx:2878
 AliTPCtracker.cxx:2879
 AliTPCtracker.cxx:2880
 AliTPCtracker.cxx:2881
 AliTPCtracker.cxx:2882
 AliTPCtracker.cxx:2883
 AliTPCtracker.cxx:2884
 AliTPCtracker.cxx:2885
 AliTPCtracker.cxx:2886
 AliTPCtracker.cxx:2887
 AliTPCtracker.cxx:2888
 AliTPCtracker.cxx:2889
 AliTPCtracker.cxx:2890
 AliTPCtracker.cxx:2891
 AliTPCtracker.cxx:2892
 AliTPCtracker.cxx:2893
 AliTPCtracker.cxx:2894
 AliTPCtracker.cxx:2895
 AliTPCtracker.cxx:2896
 AliTPCtracker.cxx:2897
 AliTPCtracker.cxx:2898
 AliTPCtracker.cxx:2899
 AliTPCtracker.cxx:2900
 AliTPCtracker.cxx:2901
 AliTPCtracker.cxx:2902
 AliTPCtracker.cxx:2903
 AliTPCtracker.cxx:2904
 AliTPCtracker.cxx:2905
 AliTPCtracker.cxx:2906
 AliTPCtracker.cxx:2907
 AliTPCtracker.cxx:2908
 AliTPCtracker.cxx:2909
 AliTPCtracker.cxx:2910
 AliTPCtracker.cxx:2911
 AliTPCtracker.cxx:2912
 AliTPCtracker.cxx:2913
 AliTPCtracker.cxx:2914
 AliTPCtracker.cxx:2915
 AliTPCtracker.cxx:2916
 AliTPCtracker.cxx:2917
 AliTPCtracker.cxx:2918
 AliTPCtracker.cxx:2919
 AliTPCtracker.cxx:2920
 AliTPCtracker.cxx:2921
 AliTPCtracker.cxx:2922
 AliTPCtracker.cxx:2923
 AliTPCtracker.cxx:2924
 AliTPCtracker.cxx:2925
 AliTPCtracker.cxx:2926
 AliTPCtracker.cxx:2927
 AliTPCtracker.cxx:2928
 AliTPCtracker.cxx:2929
 AliTPCtracker.cxx:2930
 AliTPCtracker.cxx:2931
 AliTPCtracker.cxx:2932
 AliTPCtracker.cxx:2933
 AliTPCtracker.cxx:2934
 AliTPCtracker.cxx:2935
 AliTPCtracker.cxx:2936
 AliTPCtracker.cxx:2937
 AliTPCtracker.cxx:2938
 AliTPCtracker.cxx:2939
 AliTPCtracker.cxx:2940
 AliTPCtracker.cxx:2941
 AliTPCtracker.cxx:2942
 AliTPCtracker.cxx:2943
 AliTPCtracker.cxx:2944
 AliTPCtracker.cxx:2945
 AliTPCtracker.cxx:2946
 AliTPCtracker.cxx:2947
 AliTPCtracker.cxx:2948
 AliTPCtracker.cxx:2949
 AliTPCtracker.cxx:2950
 AliTPCtracker.cxx:2951
 AliTPCtracker.cxx:2952
 AliTPCtracker.cxx:2953
 AliTPCtracker.cxx:2954
 AliTPCtracker.cxx:2955
 AliTPCtracker.cxx:2956
 AliTPCtracker.cxx:2957
 AliTPCtracker.cxx:2958
 AliTPCtracker.cxx:2959
 AliTPCtracker.cxx:2960
 AliTPCtracker.cxx:2961
 AliTPCtracker.cxx:2962
 AliTPCtracker.cxx:2963
 AliTPCtracker.cxx:2964
 AliTPCtracker.cxx:2965
 AliTPCtracker.cxx:2966
 AliTPCtracker.cxx:2967
 AliTPCtracker.cxx:2968
 AliTPCtracker.cxx:2969
 AliTPCtracker.cxx:2970
 AliTPCtracker.cxx:2971
 AliTPCtracker.cxx:2972
 AliTPCtracker.cxx:2973
 AliTPCtracker.cxx:2974
 AliTPCtracker.cxx:2975
 AliTPCtracker.cxx:2976
 AliTPCtracker.cxx:2977
 AliTPCtracker.cxx:2978
 AliTPCtracker.cxx:2979
 AliTPCtracker.cxx:2980
 AliTPCtracker.cxx:2981
 AliTPCtracker.cxx:2982
 AliTPCtracker.cxx:2983
 AliTPCtracker.cxx:2984
 AliTPCtracker.cxx:2985
 AliTPCtracker.cxx:2986
 AliTPCtracker.cxx:2987
 AliTPCtracker.cxx:2988
 AliTPCtracker.cxx:2989
 AliTPCtracker.cxx:2990
 AliTPCtracker.cxx:2991
 AliTPCtracker.cxx:2992
 AliTPCtracker.cxx:2993
 AliTPCtracker.cxx:2994
 AliTPCtracker.cxx:2995
 AliTPCtracker.cxx:2996
 AliTPCtracker.cxx:2997
 AliTPCtracker.cxx:2998
 AliTPCtracker.cxx:2999
 AliTPCtracker.cxx:3000
 AliTPCtracker.cxx:3001
 AliTPCtracker.cxx:3002
 AliTPCtracker.cxx:3003
 AliTPCtracker.cxx:3004
 AliTPCtracker.cxx:3005
 AliTPCtracker.cxx:3006
 AliTPCtracker.cxx:3007
 AliTPCtracker.cxx:3008
 AliTPCtracker.cxx:3009
 AliTPCtracker.cxx:3010
 AliTPCtracker.cxx:3011
 AliTPCtracker.cxx:3012
 AliTPCtracker.cxx:3013
 AliTPCtracker.cxx:3014
 AliTPCtracker.cxx:3015
 AliTPCtracker.cxx:3016
 AliTPCtracker.cxx:3017
 AliTPCtracker.cxx:3018
 AliTPCtracker.cxx:3019
 AliTPCtracker.cxx:3020
 AliTPCtracker.cxx:3021
 AliTPCtracker.cxx:3022
 AliTPCtracker.cxx:3023
 AliTPCtracker.cxx:3024
 AliTPCtracker.cxx:3025
 AliTPCtracker.cxx:3026
 AliTPCtracker.cxx:3027
 AliTPCtracker.cxx:3028
 AliTPCtracker.cxx:3029
 AliTPCtracker.cxx:3030
 AliTPCtracker.cxx:3031
 AliTPCtracker.cxx:3032
 AliTPCtracker.cxx:3033
 AliTPCtracker.cxx:3034
 AliTPCtracker.cxx:3035
 AliTPCtracker.cxx:3036
 AliTPCtracker.cxx:3037
 AliTPCtracker.cxx:3038
 AliTPCtracker.cxx:3039
 AliTPCtracker.cxx:3040
 AliTPCtracker.cxx:3041
 AliTPCtracker.cxx:3042
 AliTPCtracker.cxx:3043
 AliTPCtracker.cxx:3044
 AliTPCtracker.cxx:3045
 AliTPCtracker.cxx:3046
 AliTPCtracker.cxx:3047
 AliTPCtracker.cxx:3048
 AliTPCtracker.cxx:3049
 AliTPCtracker.cxx:3050
 AliTPCtracker.cxx:3051
 AliTPCtracker.cxx:3052
 AliTPCtracker.cxx:3053
 AliTPCtracker.cxx:3054
 AliTPCtracker.cxx:3055
 AliTPCtracker.cxx:3056
 AliTPCtracker.cxx:3057
 AliTPCtracker.cxx:3058
 AliTPCtracker.cxx:3059
 AliTPCtracker.cxx:3060
 AliTPCtracker.cxx:3061
 AliTPCtracker.cxx:3062
 AliTPCtracker.cxx:3063
 AliTPCtracker.cxx:3064
 AliTPCtracker.cxx:3065
 AliTPCtracker.cxx:3066
 AliTPCtracker.cxx:3067
 AliTPCtracker.cxx:3068
 AliTPCtracker.cxx:3069
 AliTPCtracker.cxx:3070
 AliTPCtracker.cxx:3071
 AliTPCtracker.cxx:3072
 AliTPCtracker.cxx:3073
 AliTPCtracker.cxx:3074
 AliTPCtracker.cxx:3075
 AliTPCtracker.cxx:3076
 AliTPCtracker.cxx:3077
 AliTPCtracker.cxx:3078
 AliTPCtracker.cxx:3079
 AliTPCtracker.cxx:3080
 AliTPCtracker.cxx:3081
 AliTPCtracker.cxx:3082
 AliTPCtracker.cxx:3083
 AliTPCtracker.cxx:3084
 AliTPCtracker.cxx:3085
 AliTPCtracker.cxx:3086
 AliTPCtracker.cxx:3087
 AliTPCtracker.cxx:3088
 AliTPCtracker.cxx:3089
 AliTPCtracker.cxx:3090
 AliTPCtracker.cxx:3091
 AliTPCtracker.cxx:3092
 AliTPCtracker.cxx:3093
 AliTPCtracker.cxx:3094
 AliTPCtracker.cxx:3095
 AliTPCtracker.cxx:3096
 AliTPCtracker.cxx:3097
 AliTPCtracker.cxx:3098
 AliTPCtracker.cxx:3099
 AliTPCtracker.cxx:3100
 AliTPCtracker.cxx:3101
 AliTPCtracker.cxx:3102
 AliTPCtracker.cxx:3103
 AliTPCtracker.cxx:3104
 AliTPCtracker.cxx:3105
 AliTPCtracker.cxx:3106
 AliTPCtracker.cxx:3107
 AliTPCtracker.cxx:3108
 AliTPCtracker.cxx:3109
 AliTPCtracker.cxx:3110
 AliTPCtracker.cxx:3111
 AliTPCtracker.cxx:3112
 AliTPCtracker.cxx:3113
 AliTPCtracker.cxx:3114
 AliTPCtracker.cxx:3115
 AliTPCtracker.cxx:3116
 AliTPCtracker.cxx:3117
 AliTPCtracker.cxx:3118
 AliTPCtracker.cxx:3119
 AliTPCtracker.cxx:3120
 AliTPCtracker.cxx:3121
 AliTPCtracker.cxx:3122
 AliTPCtracker.cxx:3123
 AliTPCtracker.cxx:3124
 AliTPCtracker.cxx:3125
 AliTPCtracker.cxx:3126
 AliTPCtracker.cxx:3127
 AliTPCtracker.cxx:3128
 AliTPCtracker.cxx:3129
 AliTPCtracker.cxx:3130
 AliTPCtracker.cxx:3131
 AliTPCtracker.cxx:3132
 AliTPCtracker.cxx:3133
 AliTPCtracker.cxx:3134
 AliTPCtracker.cxx:3135
 AliTPCtracker.cxx:3136
 AliTPCtracker.cxx:3137
 AliTPCtracker.cxx:3138
 AliTPCtracker.cxx:3139
 AliTPCtracker.cxx:3140
 AliTPCtracker.cxx:3141
 AliTPCtracker.cxx:3142
 AliTPCtracker.cxx:3143
 AliTPCtracker.cxx:3144
 AliTPCtracker.cxx:3145
 AliTPCtracker.cxx:3146
 AliTPCtracker.cxx:3147
 AliTPCtracker.cxx:3148
 AliTPCtracker.cxx:3149
 AliTPCtracker.cxx:3150
 AliTPCtracker.cxx:3151
 AliTPCtracker.cxx:3152
 AliTPCtracker.cxx:3153
 AliTPCtracker.cxx:3154
 AliTPCtracker.cxx:3155
 AliTPCtracker.cxx:3156
 AliTPCtracker.cxx:3157
 AliTPCtracker.cxx:3158
 AliTPCtracker.cxx:3159
 AliTPCtracker.cxx:3160
 AliTPCtracker.cxx:3161
 AliTPCtracker.cxx:3162
 AliTPCtracker.cxx:3163
 AliTPCtracker.cxx:3164
 AliTPCtracker.cxx:3165
 AliTPCtracker.cxx:3166
 AliTPCtracker.cxx:3167
 AliTPCtracker.cxx:3168
 AliTPCtracker.cxx:3169
 AliTPCtracker.cxx:3170
 AliTPCtracker.cxx:3171
 AliTPCtracker.cxx:3172
 AliTPCtracker.cxx:3173
 AliTPCtracker.cxx:3174
 AliTPCtracker.cxx:3175
 AliTPCtracker.cxx:3176
 AliTPCtracker.cxx:3177
 AliTPCtracker.cxx:3178
 AliTPCtracker.cxx:3179
 AliTPCtracker.cxx:3180
 AliTPCtracker.cxx:3181
 AliTPCtracker.cxx:3182
 AliTPCtracker.cxx:3183
 AliTPCtracker.cxx:3184
 AliTPCtracker.cxx:3185
 AliTPCtracker.cxx:3186
 AliTPCtracker.cxx:3187
 AliTPCtracker.cxx:3188
 AliTPCtracker.cxx:3189
 AliTPCtracker.cxx:3190
 AliTPCtracker.cxx:3191
 AliTPCtracker.cxx:3192
 AliTPCtracker.cxx:3193
 AliTPCtracker.cxx:3194
 AliTPCtracker.cxx:3195
 AliTPCtracker.cxx:3196
 AliTPCtracker.cxx:3197
 AliTPCtracker.cxx:3198
 AliTPCtracker.cxx:3199
 AliTPCtracker.cxx:3200
 AliTPCtracker.cxx:3201
 AliTPCtracker.cxx:3202
 AliTPCtracker.cxx:3203
 AliTPCtracker.cxx:3204
 AliTPCtracker.cxx:3205
 AliTPCtracker.cxx:3206
 AliTPCtracker.cxx:3207
 AliTPCtracker.cxx:3208
 AliTPCtracker.cxx:3209
 AliTPCtracker.cxx:3210
 AliTPCtracker.cxx:3211
 AliTPCtracker.cxx:3212
 AliTPCtracker.cxx:3213
 AliTPCtracker.cxx:3214
 AliTPCtracker.cxx:3215
 AliTPCtracker.cxx:3216
 AliTPCtracker.cxx:3217
 AliTPCtracker.cxx:3218
 AliTPCtracker.cxx:3219
 AliTPCtracker.cxx:3220
 AliTPCtracker.cxx:3221
 AliTPCtracker.cxx:3222
 AliTPCtracker.cxx:3223
 AliTPCtracker.cxx:3224
 AliTPCtracker.cxx:3225
 AliTPCtracker.cxx:3226
 AliTPCtracker.cxx:3227
 AliTPCtracker.cxx:3228
 AliTPCtracker.cxx:3229
 AliTPCtracker.cxx:3230
 AliTPCtracker.cxx:3231
 AliTPCtracker.cxx:3232
 AliTPCtracker.cxx:3233
 AliTPCtracker.cxx:3234
 AliTPCtracker.cxx:3235
 AliTPCtracker.cxx:3236
 AliTPCtracker.cxx:3237
 AliTPCtracker.cxx:3238
 AliTPCtracker.cxx:3239
 AliTPCtracker.cxx:3240
 AliTPCtracker.cxx:3241
 AliTPCtracker.cxx:3242
 AliTPCtracker.cxx:3243
 AliTPCtracker.cxx:3244
 AliTPCtracker.cxx:3245
 AliTPCtracker.cxx:3246
 AliTPCtracker.cxx:3247
 AliTPCtracker.cxx:3248
 AliTPCtracker.cxx:3249
 AliTPCtracker.cxx:3250
 AliTPCtracker.cxx:3251
 AliTPCtracker.cxx:3252
 AliTPCtracker.cxx:3253
 AliTPCtracker.cxx:3254
 AliTPCtracker.cxx:3255
 AliTPCtracker.cxx:3256
 AliTPCtracker.cxx:3257
 AliTPCtracker.cxx:3258
 AliTPCtracker.cxx:3259
 AliTPCtracker.cxx:3260
 AliTPCtracker.cxx:3261
 AliTPCtracker.cxx:3262
 AliTPCtracker.cxx:3263
 AliTPCtracker.cxx:3264
 AliTPCtracker.cxx:3265
 AliTPCtracker.cxx:3266
 AliTPCtracker.cxx:3267
 AliTPCtracker.cxx:3268
 AliTPCtracker.cxx:3269
 AliTPCtracker.cxx:3270
 AliTPCtracker.cxx:3271
 AliTPCtracker.cxx:3272
 AliTPCtracker.cxx:3273
 AliTPCtracker.cxx:3274
 AliTPCtracker.cxx:3275
 AliTPCtracker.cxx:3276
 AliTPCtracker.cxx:3277
 AliTPCtracker.cxx:3278
 AliTPCtracker.cxx:3279
 AliTPCtracker.cxx:3280
 AliTPCtracker.cxx:3281
 AliTPCtracker.cxx:3282
 AliTPCtracker.cxx:3283
 AliTPCtracker.cxx:3284
 AliTPCtracker.cxx:3285
 AliTPCtracker.cxx:3286
 AliTPCtracker.cxx:3287
 AliTPCtracker.cxx:3288
 AliTPCtracker.cxx:3289
 AliTPCtracker.cxx:3290
 AliTPCtracker.cxx:3291
 AliTPCtracker.cxx:3292
 AliTPCtracker.cxx:3293
 AliTPCtracker.cxx:3294
 AliTPCtracker.cxx:3295
 AliTPCtracker.cxx:3296
 AliTPCtracker.cxx:3297
 AliTPCtracker.cxx:3298
 AliTPCtracker.cxx:3299
 AliTPCtracker.cxx:3300
 AliTPCtracker.cxx:3301
 AliTPCtracker.cxx:3302
 AliTPCtracker.cxx:3303
 AliTPCtracker.cxx:3304
 AliTPCtracker.cxx:3305
 AliTPCtracker.cxx:3306
 AliTPCtracker.cxx:3307
 AliTPCtracker.cxx:3308
 AliTPCtracker.cxx:3309
 AliTPCtracker.cxx:3310
 AliTPCtracker.cxx:3311
 AliTPCtracker.cxx:3312
 AliTPCtracker.cxx:3313
 AliTPCtracker.cxx:3314
 AliTPCtracker.cxx:3315
 AliTPCtracker.cxx:3316
 AliTPCtracker.cxx:3317
 AliTPCtracker.cxx:3318
 AliTPCtracker.cxx:3319
 AliTPCtracker.cxx:3320
 AliTPCtracker.cxx:3321
 AliTPCtracker.cxx:3322
 AliTPCtracker.cxx:3323
 AliTPCtracker.cxx:3324
 AliTPCtracker.cxx:3325
 AliTPCtracker.cxx:3326
 AliTPCtracker.cxx:3327
 AliTPCtracker.cxx:3328
 AliTPCtracker.cxx:3329
 AliTPCtracker.cxx:3330
 AliTPCtracker.cxx:3331
 AliTPCtracker.cxx:3332
 AliTPCtracker.cxx:3333
 AliTPCtracker.cxx:3334
 AliTPCtracker.cxx:3335
 AliTPCtracker.cxx:3336
 AliTPCtracker.cxx:3337
 AliTPCtracker.cxx:3338
 AliTPCtracker.cxx:3339
 AliTPCtracker.cxx:3340
 AliTPCtracker.cxx:3341
 AliTPCtracker.cxx:3342
 AliTPCtracker.cxx:3343
 AliTPCtracker.cxx:3344
 AliTPCtracker.cxx:3345
 AliTPCtracker.cxx:3346
 AliTPCtracker.cxx:3347
 AliTPCtracker.cxx:3348
 AliTPCtracker.cxx:3349
 AliTPCtracker.cxx:3350
 AliTPCtracker.cxx:3351
 AliTPCtracker.cxx:3352
 AliTPCtracker.cxx:3353
 AliTPCtracker.cxx:3354
 AliTPCtracker.cxx:3355
 AliTPCtracker.cxx:3356
 AliTPCtracker.cxx:3357
 AliTPCtracker.cxx:3358
 AliTPCtracker.cxx:3359
 AliTPCtracker.cxx:3360
 AliTPCtracker.cxx:3361
 AliTPCtracker.cxx:3362
 AliTPCtracker.cxx:3363
 AliTPCtracker.cxx:3364
 AliTPCtracker.cxx:3365
 AliTPCtracker.cxx:3366
 AliTPCtracker.cxx:3367
 AliTPCtracker.cxx:3368
 AliTPCtracker.cxx:3369
 AliTPCtracker.cxx:3370
 AliTPCtracker.cxx:3371
 AliTPCtracker.cxx:3372
 AliTPCtracker.cxx:3373
 AliTPCtracker.cxx:3374
 AliTPCtracker.cxx:3375
 AliTPCtracker.cxx:3376
 AliTPCtracker.cxx:3377
 AliTPCtracker.cxx:3378
 AliTPCtracker.cxx:3379
 AliTPCtracker.cxx:3380
 AliTPCtracker.cxx:3381
 AliTPCtracker.cxx:3382
 AliTPCtracker.cxx:3383
 AliTPCtracker.cxx:3384
 AliTPCtracker.cxx:3385
 AliTPCtracker.cxx:3386
 AliTPCtracker.cxx:3387
 AliTPCtracker.cxx:3388
 AliTPCtracker.cxx:3389
 AliTPCtracker.cxx:3390
 AliTPCtracker.cxx:3391
 AliTPCtracker.cxx:3392
 AliTPCtracker.cxx:3393
 AliTPCtracker.cxx:3394
 AliTPCtracker.cxx:3395
 AliTPCtracker.cxx:3396
 AliTPCtracker.cxx:3397
 AliTPCtracker.cxx:3398
 AliTPCtracker.cxx:3399
 AliTPCtracker.cxx:3400
 AliTPCtracker.cxx:3401
 AliTPCtracker.cxx:3402
 AliTPCtracker.cxx:3403
 AliTPCtracker.cxx:3404
 AliTPCtracker.cxx:3405
 AliTPCtracker.cxx:3406
 AliTPCtracker.cxx:3407
 AliTPCtracker.cxx:3408
 AliTPCtracker.cxx:3409
 AliTPCtracker.cxx:3410
 AliTPCtracker.cxx:3411
 AliTPCtracker.cxx:3412
 AliTPCtracker.cxx:3413
 AliTPCtracker.cxx:3414
 AliTPCtracker.cxx:3415
 AliTPCtracker.cxx:3416
 AliTPCtracker.cxx:3417
 AliTPCtracker.cxx:3418
 AliTPCtracker.cxx:3419
 AliTPCtracker.cxx:3420
 AliTPCtracker.cxx:3421
 AliTPCtracker.cxx:3422
 AliTPCtracker.cxx:3423
 AliTPCtracker.cxx:3424
 AliTPCtracker.cxx:3425
 AliTPCtracker.cxx:3426
 AliTPCtracker.cxx:3427
 AliTPCtracker.cxx:3428
 AliTPCtracker.cxx:3429
 AliTPCtracker.cxx:3430
 AliTPCtracker.cxx:3431
 AliTPCtracker.cxx:3432
 AliTPCtracker.cxx:3433
 AliTPCtracker.cxx:3434
 AliTPCtracker.cxx:3435
 AliTPCtracker.cxx:3436
 AliTPCtracker.cxx:3437
 AliTPCtracker.cxx:3438
 AliTPCtracker.cxx:3439
 AliTPCtracker.cxx:3440
 AliTPCtracker.cxx:3441
 AliTPCtracker.cxx:3442
 AliTPCtracker.cxx:3443
 AliTPCtracker.cxx:3444
 AliTPCtracker.cxx:3445
 AliTPCtracker.cxx:3446
 AliTPCtracker.cxx:3447
 AliTPCtracker.cxx:3448
 AliTPCtracker.cxx:3449
 AliTPCtracker.cxx:3450
 AliTPCtracker.cxx:3451
 AliTPCtracker.cxx:3452
 AliTPCtracker.cxx:3453
 AliTPCtracker.cxx:3454
 AliTPCtracker.cxx:3455
 AliTPCtracker.cxx:3456
 AliTPCtracker.cxx:3457
 AliTPCtracker.cxx:3458
 AliTPCtracker.cxx:3459
 AliTPCtracker.cxx:3460
 AliTPCtracker.cxx:3461
 AliTPCtracker.cxx:3462
 AliTPCtracker.cxx:3463
 AliTPCtracker.cxx:3464
 AliTPCtracker.cxx:3465
 AliTPCtracker.cxx:3466
 AliTPCtracker.cxx:3467
 AliTPCtracker.cxx:3468
 AliTPCtracker.cxx:3469
 AliTPCtracker.cxx:3470
 AliTPCtracker.cxx:3471
 AliTPCtracker.cxx:3472
 AliTPCtracker.cxx:3473
 AliTPCtracker.cxx:3474
 AliTPCtracker.cxx:3475
 AliTPCtracker.cxx:3476
 AliTPCtracker.cxx:3477
 AliTPCtracker.cxx:3478
 AliTPCtracker.cxx:3479
 AliTPCtracker.cxx:3480
 AliTPCtracker.cxx:3481
 AliTPCtracker.cxx:3482
 AliTPCtracker.cxx:3483
 AliTPCtracker.cxx:3484
 AliTPCtracker.cxx:3485
 AliTPCtracker.cxx:3486
 AliTPCtracker.cxx:3487
 AliTPCtracker.cxx:3488
 AliTPCtracker.cxx:3489
 AliTPCtracker.cxx:3490
 AliTPCtracker.cxx:3491
 AliTPCtracker.cxx:3492
 AliTPCtracker.cxx:3493
 AliTPCtracker.cxx:3494
 AliTPCtracker.cxx:3495
 AliTPCtracker.cxx:3496
 AliTPCtracker.cxx:3497
 AliTPCtracker.cxx:3498
 AliTPCtracker.cxx:3499
 AliTPCtracker.cxx:3500
 AliTPCtracker.cxx:3501
 AliTPCtracker.cxx:3502
 AliTPCtracker.cxx:3503
 AliTPCtracker.cxx:3504
 AliTPCtracker.cxx:3505
 AliTPCtracker.cxx:3506
 AliTPCtracker.cxx:3507
 AliTPCtracker.cxx:3508
 AliTPCtracker.cxx:3509
 AliTPCtracker.cxx:3510
 AliTPCtracker.cxx:3511
 AliTPCtracker.cxx:3512
 AliTPCtracker.cxx:3513
 AliTPCtracker.cxx:3514
 AliTPCtracker.cxx:3515
 AliTPCtracker.cxx:3516
 AliTPCtracker.cxx:3517
 AliTPCtracker.cxx:3518
 AliTPCtracker.cxx:3519
 AliTPCtracker.cxx:3520
 AliTPCtracker.cxx:3521
 AliTPCtracker.cxx:3522
 AliTPCtracker.cxx:3523
 AliTPCtracker.cxx:3524
 AliTPCtracker.cxx:3525
 AliTPCtracker.cxx:3526
 AliTPCtracker.cxx:3527
 AliTPCtracker.cxx:3528
 AliTPCtracker.cxx:3529
 AliTPCtracker.cxx:3530
 AliTPCtracker.cxx:3531
 AliTPCtracker.cxx:3532
 AliTPCtracker.cxx:3533
 AliTPCtracker.cxx:3534
 AliTPCtracker.cxx:3535
 AliTPCtracker.cxx:3536
 AliTPCtracker.cxx:3537
 AliTPCtracker.cxx:3538
 AliTPCtracker.cxx:3539
 AliTPCtracker.cxx:3540
 AliTPCtracker.cxx:3541
 AliTPCtracker.cxx:3542
 AliTPCtracker.cxx:3543
 AliTPCtracker.cxx:3544
 AliTPCtracker.cxx:3545
 AliTPCtracker.cxx:3546
 AliTPCtracker.cxx:3547
 AliTPCtracker.cxx:3548
 AliTPCtracker.cxx:3549
 AliTPCtracker.cxx:3550
 AliTPCtracker.cxx:3551
 AliTPCtracker.cxx:3552
 AliTPCtracker.cxx:3553
 AliTPCtracker.cxx:3554
 AliTPCtracker.cxx:3555
 AliTPCtracker.cxx:3556
 AliTPCtracker.cxx:3557
 AliTPCtracker.cxx:3558
 AliTPCtracker.cxx:3559
 AliTPCtracker.cxx:3560
 AliTPCtracker.cxx:3561
 AliTPCtracker.cxx:3562
 AliTPCtracker.cxx:3563
 AliTPCtracker.cxx:3564
 AliTPCtracker.cxx:3565
 AliTPCtracker.cxx:3566
 AliTPCtracker.cxx:3567
 AliTPCtracker.cxx:3568
 AliTPCtracker.cxx:3569
 AliTPCtracker.cxx:3570
 AliTPCtracker.cxx:3571
 AliTPCtracker.cxx:3572
 AliTPCtracker.cxx:3573
 AliTPCtracker.cxx:3574
 AliTPCtracker.cxx:3575
 AliTPCtracker.cxx:3576
 AliTPCtracker.cxx:3577
 AliTPCtracker.cxx:3578
 AliTPCtracker.cxx:3579
 AliTPCtracker.cxx:3580
 AliTPCtracker.cxx:3581
 AliTPCtracker.cxx:3582
 AliTPCtracker.cxx:3583
 AliTPCtracker.cxx:3584
 AliTPCtracker.cxx:3585
 AliTPCtracker.cxx:3586
 AliTPCtracker.cxx:3587
 AliTPCtracker.cxx:3588
 AliTPCtracker.cxx:3589
 AliTPCtracker.cxx:3590
 AliTPCtracker.cxx:3591
 AliTPCtracker.cxx:3592
 AliTPCtracker.cxx:3593
 AliTPCtracker.cxx:3594
 AliTPCtracker.cxx:3595
 AliTPCtracker.cxx:3596
 AliTPCtracker.cxx:3597
 AliTPCtracker.cxx:3598
 AliTPCtracker.cxx:3599
 AliTPCtracker.cxx:3600
 AliTPCtracker.cxx:3601
 AliTPCtracker.cxx:3602
 AliTPCtracker.cxx:3603
 AliTPCtracker.cxx:3604
 AliTPCtracker.cxx:3605
 AliTPCtracker.cxx:3606
 AliTPCtracker.cxx:3607
 AliTPCtracker.cxx:3608
 AliTPCtracker.cxx:3609
 AliTPCtracker.cxx:3610
 AliTPCtracker.cxx:3611
 AliTPCtracker.cxx:3612
 AliTPCtracker.cxx:3613
 AliTPCtracker.cxx:3614
 AliTPCtracker.cxx:3615
 AliTPCtracker.cxx:3616
 AliTPCtracker.cxx:3617
 AliTPCtracker.cxx:3618
 AliTPCtracker.cxx:3619
 AliTPCtracker.cxx:3620
 AliTPCtracker.cxx:3621
 AliTPCtracker.cxx:3622
 AliTPCtracker.cxx:3623
 AliTPCtracker.cxx:3624
 AliTPCtracker.cxx:3625
 AliTPCtracker.cxx:3626
 AliTPCtracker.cxx:3627
 AliTPCtracker.cxx:3628
 AliTPCtracker.cxx:3629
 AliTPCtracker.cxx:3630
 AliTPCtracker.cxx:3631
 AliTPCtracker.cxx:3632
 AliTPCtracker.cxx:3633
 AliTPCtracker.cxx:3634
 AliTPCtracker.cxx:3635
 AliTPCtracker.cxx:3636
 AliTPCtracker.cxx:3637
 AliTPCtracker.cxx:3638
 AliTPCtracker.cxx:3639
 AliTPCtracker.cxx:3640
 AliTPCtracker.cxx:3641
 AliTPCtracker.cxx:3642
 AliTPCtracker.cxx:3643
 AliTPCtracker.cxx:3644
 AliTPCtracker.cxx:3645
 AliTPCtracker.cxx:3646
 AliTPCtracker.cxx:3647
 AliTPCtracker.cxx:3648
 AliTPCtracker.cxx:3649
 AliTPCtracker.cxx:3650
 AliTPCtracker.cxx:3651
 AliTPCtracker.cxx:3652
 AliTPCtracker.cxx:3653
 AliTPCtracker.cxx:3654
 AliTPCtracker.cxx:3655
 AliTPCtracker.cxx:3656
 AliTPCtracker.cxx:3657
 AliTPCtracker.cxx:3658
 AliTPCtracker.cxx:3659
 AliTPCtracker.cxx:3660
 AliTPCtracker.cxx:3661
 AliTPCtracker.cxx:3662
 AliTPCtracker.cxx:3663
 AliTPCtracker.cxx:3664
 AliTPCtracker.cxx:3665
 AliTPCtracker.cxx:3666
 AliTPCtracker.cxx:3667
 AliTPCtracker.cxx:3668
 AliTPCtracker.cxx:3669
 AliTPCtracker.cxx:3670
 AliTPCtracker.cxx:3671
 AliTPCtracker.cxx:3672
 AliTPCtracker.cxx:3673
 AliTPCtracker.cxx:3674
 AliTPCtracker.cxx:3675
 AliTPCtracker.cxx:3676
 AliTPCtracker.cxx:3677
 AliTPCtracker.cxx:3678
 AliTPCtracker.cxx:3679
 AliTPCtracker.cxx:3680
 AliTPCtracker.cxx:3681
 AliTPCtracker.cxx:3682
 AliTPCtracker.cxx:3683
 AliTPCtracker.cxx:3684
 AliTPCtracker.cxx:3685
 AliTPCtracker.cxx:3686
 AliTPCtracker.cxx:3687
 AliTPCtracker.cxx:3688
 AliTPCtracker.cxx:3689
 AliTPCtracker.cxx:3690
 AliTPCtracker.cxx:3691
 AliTPCtracker.cxx:3692
 AliTPCtracker.cxx:3693
 AliTPCtracker.cxx:3694
 AliTPCtracker.cxx:3695
 AliTPCtracker.cxx:3696
 AliTPCtracker.cxx:3697
 AliTPCtracker.cxx:3698
 AliTPCtracker.cxx:3699
 AliTPCtracker.cxx:3700
 AliTPCtracker.cxx:3701
 AliTPCtracker.cxx:3702
 AliTPCtracker.cxx:3703
 AliTPCtracker.cxx:3704
 AliTPCtracker.cxx:3705
 AliTPCtracker.cxx:3706
 AliTPCtracker.cxx:3707
 AliTPCtracker.cxx:3708
 AliTPCtracker.cxx:3709
 AliTPCtracker.cxx:3710
 AliTPCtracker.cxx:3711
 AliTPCtracker.cxx:3712
 AliTPCtracker.cxx:3713
 AliTPCtracker.cxx:3714
 AliTPCtracker.cxx:3715
 AliTPCtracker.cxx:3716
 AliTPCtracker.cxx:3717
 AliTPCtracker.cxx:3718
 AliTPCtracker.cxx:3719
 AliTPCtracker.cxx:3720
 AliTPCtracker.cxx:3721
 AliTPCtracker.cxx:3722
 AliTPCtracker.cxx:3723
 AliTPCtracker.cxx:3724
 AliTPCtracker.cxx:3725
 AliTPCtracker.cxx:3726
 AliTPCtracker.cxx:3727
 AliTPCtracker.cxx:3728
 AliTPCtracker.cxx:3729
 AliTPCtracker.cxx:3730
 AliTPCtracker.cxx:3731
 AliTPCtracker.cxx:3732
 AliTPCtracker.cxx:3733
 AliTPCtracker.cxx:3734
 AliTPCtracker.cxx:3735
 AliTPCtracker.cxx:3736
 AliTPCtracker.cxx:3737
 AliTPCtracker.cxx:3738
 AliTPCtracker.cxx:3739
 AliTPCtracker.cxx:3740
 AliTPCtracker.cxx:3741
 AliTPCtracker.cxx:3742
 AliTPCtracker.cxx:3743
 AliTPCtracker.cxx:3744
 AliTPCtracker.cxx:3745
 AliTPCtracker.cxx:3746
 AliTPCtracker.cxx:3747
 AliTPCtracker.cxx:3748
 AliTPCtracker.cxx:3749
 AliTPCtracker.cxx:3750
 AliTPCtracker.cxx:3751
 AliTPCtracker.cxx:3752
 AliTPCtracker.cxx:3753
 AliTPCtracker.cxx:3754
 AliTPCtracker.cxx:3755
 AliTPCtracker.cxx:3756
 AliTPCtracker.cxx:3757
 AliTPCtracker.cxx:3758
 AliTPCtracker.cxx:3759
 AliTPCtracker.cxx:3760
 AliTPCtracker.cxx:3761
 AliTPCtracker.cxx:3762
 AliTPCtracker.cxx:3763
 AliTPCtracker.cxx:3764
 AliTPCtracker.cxx:3765
 AliTPCtracker.cxx:3766
 AliTPCtracker.cxx:3767
 AliTPCtracker.cxx:3768
 AliTPCtracker.cxx:3769
 AliTPCtracker.cxx:3770
 AliTPCtracker.cxx:3771
 AliTPCtracker.cxx:3772
 AliTPCtracker.cxx:3773
 AliTPCtracker.cxx:3774
 AliTPCtracker.cxx:3775
 AliTPCtracker.cxx:3776
 AliTPCtracker.cxx:3777
 AliTPCtracker.cxx:3778
 AliTPCtracker.cxx:3779
 AliTPCtracker.cxx:3780
 AliTPCtracker.cxx:3781
 AliTPCtracker.cxx:3782
 AliTPCtracker.cxx:3783
 AliTPCtracker.cxx:3784
 AliTPCtracker.cxx:3785
 AliTPCtracker.cxx:3786
 AliTPCtracker.cxx:3787
 AliTPCtracker.cxx:3788
 AliTPCtracker.cxx:3789
 AliTPCtracker.cxx:3790
 AliTPCtracker.cxx:3791
 AliTPCtracker.cxx:3792
 AliTPCtracker.cxx:3793
 AliTPCtracker.cxx:3794
 AliTPCtracker.cxx:3795
 AliTPCtracker.cxx:3796
 AliTPCtracker.cxx:3797
 AliTPCtracker.cxx:3798
 AliTPCtracker.cxx:3799
 AliTPCtracker.cxx:3800
 AliTPCtracker.cxx:3801
 AliTPCtracker.cxx:3802
 AliTPCtracker.cxx:3803
 AliTPCtracker.cxx:3804
 AliTPCtracker.cxx:3805
 AliTPCtracker.cxx:3806
 AliTPCtracker.cxx:3807
 AliTPCtracker.cxx:3808
 AliTPCtracker.cxx:3809
 AliTPCtracker.cxx:3810
 AliTPCtracker.cxx:3811
 AliTPCtracker.cxx:3812
 AliTPCtracker.cxx:3813
 AliTPCtracker.cxx:3814
 AliTPCtracker.cxx:3815
 AliTPCtracker.cxx:3816
 AliTPCtracker.cxx:3817
 AliTPCtracker.cxx:3818
 AliTPCtracker.cxx:3819
 AliTPCtracker.cxx:3820
 AliTPCtracker.cxx:3821
 AliTPCtracker.cxx:3822
 AliTPCtracker.cxx:3823
 AliTPCtracker.cxx:3824
 AliTPCtracker.cxx:3825
 AliTPCtracker.cxx:3826
 AliTPCtracker.cxx:3827
 AliTPCtracker.cxx:3828
 AliTPCtracker.cxx:3829
 AliTPCtracker.cxx:3830
 AliTPCtracker.cxx:3831
 AliTPCtracker.cxx:3832
 AliTPCtracker.cxx:3833
 AliTPCtracker.cxx:3834
 AliTPCtracker.cxx:3835
 AliTPCtracker.cxx:3836
 AliTPCtracker.cxx:3837
 AliTPCtracker.cxx:3838
 AliTPCtracker.cxx:3839
 AliTPCtracker.cxx:3840
 AliTPCtracker.cxx:3841
 AliTPCtracker.cxx:3842
 AliTPCtracker.cxx:3843
 AliTPCtracker.cxx:3844
 AliTPCtracker.cxx:3845
 AliTPCtracker.cxx:3846
 AliTPCtracker.cxx:3847
 AliTPCtracker.cxx:3848
 AliTPCtracker.cxx:3849
 AliTPCtracker.cxx:3850
 AliTPCtracker.cxx:3851
 AliTPCtracker.cxx:3852
 AliTPCtracker.cxx:3853
 AliTPCtracker.cxx:3854
 AliTPCtracker.cxx:3855
 AliTPCtracker.cxx:3856
 AliTPCtracker.cxx:3857
 AliTPCtracker.cxx:3858
 AliTPCtracker.cxx:3859
 AliTPCtracker.cxx:3860
 AliTPCtracker.cxx:3861
 AliTPCtracker.cxx:3862
 AliTPCtracker.cxx:3863
 AliTPCtracker.cxx:3864
 AliTPCtracker.cxx:3865
 AliTPCtracker.cxx:3866
 AliTPCtracker.cxx:3867
 AliTPCtracker.cxx:3868
 AliTPCtracker.cxx:3869
 AliTPCtracker.cxx:3870
 AliTPCtracker.cxx:3871
 AliTPCtracker.cxx:3872
 AliTPCtracker.cxx:3873
 AliTPCtracker.cxx:3874
 AliTPCtracker.cxx:3875
 AliTPCtracker.cxx:3876
 AliTPCtracker.cxx:3877
 AliTPCtracker.cxx:3878
 AliTPCtracker.cxx:3879
 AliTPCtracker.cxx:3880
 AliTPCtracker.cxx:3881
 AliTPCtracker.cxx:3882
 AliTPCtracker.cxx:3883
 AliTPCtracker.cxx:3884
 AliTPCtracker.cxx:3885
 AliTPCtracker.cxx:3886
 AliTPCtracker.cxx:3887
 AliTPCtracker.cxx:3888
 AliTPCtracker.cxx:3889
 AliTPCtracker.cxx:3890
 AliTPCtracker.cxx:3891
 AliTPCtracker.cxx:3892
 AliTPCtracker.cxx:3893
 AliTPCtracker.cxx:3894
 AliTPCtracker.cxx:3895
 AliTPCtracker.cxx:3896
 AliTPCtracker.cxx:3897
 AliTPCtracker.cxx:3898
 AliTPCtracker.cxx:3899
 AliTPCtracker.cxx:3900
 AliTPCtracker.cxx:3901
 AliTPCtracker.cxx:3902
 AliTPCtracker.cxx:3903
 AliTPCtracker.cxx:3904
 AliTPCtracker.cxx:3905
 AliTPCtracker.cxx:3906
 AliTPCtracker.cxx:3907
 AliTPCtracker.cxx:3908
 AliTPCtracker.cxx:3909
 AliTPCtracker.cxx:3910
 AliTPCtracker.cxx:3911
 AliTPCtracker.cxx:3912
 AliTPCtracker.cxx:3913
 AliTPCtracker.cxx:3914
 AliTPCtracker.cxx:3915
 AliTPCtracker.cxx:3916
 AliTPCtracker.cxx:3917
 AliTPCtracker.cxx:3918
 AliTPCtracker.cxx:3919
 AliTPCtracker.cxx:3920
 AliTPCtracker.cxx:3921
 AliTPCtracker.cxx:3922
 AliTPCtracker.cxx:3923
 AliTPCtracker.cxx:3924
 AliTPCtracker.cxx:3925
 AliTPCtracker.cxx:3926
 AliTPCtracker.cxx:3927
 AliTPCtracker.cxx:3928
 AliTPCtracker.cxx:3929
 AliTPCtracker.cxx:3930
 AliTPCtracker.cxx:3931
 AliTPCtracker.cxx:3932
 AliTPCtracker.cxx:3933
 AliTPCtracker.cxx:3934
 AliTPCtracker.cxx:3935
 AliTPCtracker.cxx:3936
 AliTPCtracker.cxx:3937
 AliTPCtracker.cxx:3938
 AliTPCtracker.cxx:3939
 AliTPCtracker.cxx:3940
 AliTPCtracker.cxx:3941
 AliTPCtracker.cxx:3942
 AliTPCtracker.cxx:3943
 AliTPCtracker.cxx:3944
 AliTPCtracker.cxx:3945
 AliTPCtracker.cxx:3946
 AliTPCtracker.cxx:3947
 AliTPCtracker.cxx:3948
 AliTPCtracker.cxx:3949
 AliTPCtracker.cxx:3950
 AliTPCtracker.cxx:3951
 AliTPCtracker.cxx:3952
 AliTPCtracker.cxx:3953
 AliTPCtracker.cxx:3954
 AliTPCtracker.cxx:3955
 AliTPCtracker.cxx:3956
 AliTPCtracker.cxx:3957
 AliTPCtracker.cxx:3958
 AliTPCtracker.cxx:3959
 AliTPCtracker.cxx:3960
 AliTPCtracker.cxx:3961
 AliTPCtracker.cxx:3962
 AliTPCtracker.cxx:3963
 AliTPCtracker.cxx:3964
 AliTPCtracker.cxx:3965
 AliTPCtracker.cxx:3966
 AliTPCtracker.cxx:3967
 AliTPCtracker.cxx:3968
 AliTPCtracker.cxx:3969
 AliTPCtracker.cxx:3970
 AliTPCtracker.cxx:3971
 AliTPCtracker.cxx:3972
 AliTPCtracker.cxx:3973
 AliTPCtracker.cxx:3974
 AliTPCtracker.cxx:3975
 AliTPCtracker.cxx:3976
 AliTPCtracker.cxx:3977
 AliTPCtracker.cxx:3978
 AliTPCtracker.cxx:3979
 AliTPCtracker.cxx:3980
 AliTPCtracker.cxx:3981
 AliTPCtracker.cxx:3982
 AliTPCtracker.cxx:3983
 AliTPCtracker.cxx:3984
 AliTPCtracker.cxx:3985
 AliTPCtracker.cxx:3986
 AliTPCtracker.cxx:3987
 AliTPCtracker.cxx:3988
 AliTPCtracker.cxx:3989
 AliTPCtracker.cxx:3990
 AliTPCtracker.cxx:3991
 AliTPCtracker.cxx:3992
 AliTPCtracker.cxx:3993
 AliTPCtracker.cxx:3994
 AliTPCtracker.cxx:3995
 AliTPCtracker.cxx:3996
 AliTPCtracker.cxx:3997
 AliTPCtracker.cxx:3998
 AliTPCtracker.cxx:3999
 AliTPCtracker.cxx:4000
 AliTPCtracker.cxx:4001
 AliTPCtracker.cxx:4002
 AliTPCtracker.cxx:4003
 AliTPCtracker.cxx:4004
 AliTPCtracker.cxx:4005
 AliTPCtracker.cxx:4006
 AliTPCtracker.cxx:4007
 AliTPCtracker.cxx:4008
 AliTPCtracker.cxx:4009
 AliTPCtracker.cxx:4010
 AliTPCtracker.cxx:4011
 AliTPCtracker.cxx:4012
 AliTPCtracker.cxx:4013
 AliTPCtracker.cxx:4014
 AliTPCtracker.cxx:4015
 AliTPCtracker.cxx:4016
 AliTPCtracker.cxx:4017
 AliTPCtracker.cxx:4018
 AliTPCtracker.cxx:4019
 AliTPCtracker.cxx:4020
 AliTPCtracker.cxx:4021
 AliTPCtracker.cxx:4022
 AliTPCtracker.cxx:4023
 AliTPCtracker.cxx:4024
 AliTPCtracker.cxx:4025
 AliTPCtracker.cxx:4026
 AliTPCtracker.cxx:4027
 AliTPCtracker.cxx:4028
 AliTPCtracker.cxx:4029
 AliTPCtracker.cxx:4030
 AliTPCtracker.cxx:4031
 AliTPCtracker.cxx:4032
 AliTPCtracker.cxx:4033
 AliTPCtracker.cxx:4034
 AliTPCtracker.cxx:4035
 AliTPCtracker.cxx:4036
 AliTPCtracker.cxx:4037
 AliTPCtracker.cxx:4038
 AliTPCtracker.cxx:4039
 AliTPCtracker.cxx:4040
 AliTPCtracker.cxx:4041
 AliTPCtracker.cxx:4042
 AliTPCtracker.cxx:4043
 AliTPCtracker.cxx:4044
 AliTPCtracker.cxx:4045
 AliTPCtracker.cxx:4046
 AliTPCtracker.cxx:4047
 AliTPCtracker.cxx:4048
 AliTPCtracker.cxx:4049
 AliTPCtracker.cxx:4050
 AliTPCtracker.cxx:4051
 AliTPCtracker.cxx:4052
 AliTPCtracker.cxx:4053
 AliTPCtracker.cxx:4054
 AliTPCtracker.cxx:4055
 AliTPCtracker.cxx:4056
 AliTPCtracker.cxx:4057
 AliTPCtracker.cxx:4058
 AliTPCtracker.cxx:4059
 AliTPCtracker.cxx:4060
 AliTPCtracker.cxx:4061
 AliTPCtracker.cxx:4062
 AliTPCtracker.cxx:4063
 AliTPCtracker.cxx:4064
 AliTPCtracker.cxx:4065
 AliTPCtracker.cxx:4066
 AliTPCtracker.cxx:4067
 AliTPCtracker.cxx:4068
 AliTPCtracker.cxx:4069
 AliTPCtracker.cxx:4070
 AliTPCtracker.cxx:4071
 AliTPCtracker.cxx:4072
 AliTPCtracker.cxx:4073
 AliTPCtracker.cxx:4074
 AliTPCtracker.cxx:4075
 AliTPCtracker.cxx:4076
 AliTPCtracker.cxx:4077
 AliTPCtracker.cxx:4078
 AliTPCtracker.cxx:4079
 AliTPCtracker.cxx:4080
 AliTPCtracker.cxx:4081
 AliTPCtracker.cxx:4082
 AliTPCtracker.cxx:4083
 AliTPCtracker.cxx:4084
 AliTPCtracker.cxx:4085
 AliTPCtracker.cxx:4086
 AliTPCtracker.cxx:4087
 AliTPCtracker.cxx:4088
 AliTPCtracker.cxx:4089
 AliTPCtracker.cxx:4090
 AliTPCtracker.cxx:4091
 AliTPCtracker.cxx:4092
 AliTPCtracker.cxx:4093
 AliTPCtracker.cxx:4094
 AliTPCtracker.cxx:4095
 AliTPCtracker.cxx:4096
 AliTPCtracker.cxx:4097
 AliTPCtracker.cxx:4098
 AliTPCtracker.cxx:4099
 AliTPCtracker.cxx:4100
 AliTPCtracker.cxx:4101
 AliTPCtracker.cxx:4102
 AliTPCtracker.cxx:4103
 AliTPCtracker.cxx:4104
 AliTPCtracker.cxx:4105
 AliTPCtracker.cxx:4106
 AliTPCtracker.cxx:4107
 AliTPCtracker.cxx:4108
 AliTPCtracker.cxx:4109
 AliTPCtracker.cxx:4110
 AliTPCtracker.cxx:4111
 AliTPCtracker.cxx:4112
 AliTPCtracker.cxx:4113
 AliTPCtracker.cxx:4114
 AliTPCtracker.cxx:4115
 AliTPCtracker.cxx:4116
 AliTPCtracker.cxx:4117
 AliTPCtracker.cxx:4118
 AliTPCtracker.cxx:4119
 AliTPCtracker.cxx:4120
 AliTPCtracker.cxx:4121
 AliTPCtracker.cxx:4122
 AliTPCtracker.cxx:4123
 AliTPCtracker.cxx:4124
 AliTPCtracker.cxx:4125
 AliTPCtracker.cxx:4126
 AliTPCtracker.cxx:4127
 AliTPCtracker.cxx:4128
 AliTPCtracker.cxx:4129
 AliTPCtracker.cxx:4130
 AliTPCtracker.cxx:4131
 AliTPCtracker.cxx:4132
 AliTPCtracker.cxx:4133
 AliTPCtracker.cxx:4134
 AliTPCtracker.cxx:4135
 AliTPCtracker.cxx:4136
 AliTPCtracker.cxx:4137
 AliTPCtracker.cxx:4138
 AliTPCtracker.cxx:4139
 AliTPCtracker.cxx:4140
 AliTPCtracker.cxx:4141
 AliTPCtracker.cxx:4142
 AliTPCtracker.cxx:4143
 AliTPCtracker.cxx:4144
 AliTPCtracker.cxx:4145
 AliTPCtracker.cxx:4146
 AliTPCtracker.cxx:4147
 AliTPCtracker.cxx:4148
 AliTPCtracker.cxx:4149
 AliTPCtracker.cxx:4150
 AliTPCtracker.cxx:4151
 AliTPCtracker.cxx:4152
 AliTPCtracker.cxx:4153
 AliTPCtracker.cxx:4154
 AliTPCtracker.cxx:4155
 AliTPCtracker.cxx:4156
 AliTPCtracker.cxx:4157
 AliTPCtracker.cxx:4158
 AliTPCtracker.cxx:4159
 AliTPCtracker.cxx:4160
 AliTPCtracker.cxx:4161
 AliTPCtracker.cxx:4162
 AliTPCtracker.cxx:4163
 AliTPCtracker.cxx:4164
 AliTPCtracker.cxx:4165
 AliTPCtracker.cxx:4166
 AliTPCtracker.cxx:4167
 AliTPCtracker.cxx:4168
 AliTPCtracker.cxx:4169
 AliTPCtracker.cxx:4170
 AliTPCtracker.cxx:4171
 AliTPCtracker.cxx:4172
 AliTPCtracker.cxx:4173
 AliTPCtracker.cxx:4174
 AliTPCtracker.cxx:4175
 AliTPCtracker.cxx:4176
 AliTPCtracker.cxx:4177
 AliTPCtracker.cxx:4178
 AliTPCtracker.cxx:4179
 AliTPCtracker.cxx:4180
 AliTPCtracker.cxx:4181
 AliTPCtracker.cxx:4182
 AliTPCtracker.cxx:4183
 AliTPCtracker.cxx:4184
 AliTPCtracker.cxx:4185
 AliTPCtracker.cxx:4186
 AliTPCtracker.cxx:4187
 AliTPCtracker.cxx:4188
 AliTPCtracker.cxx:4189
 AliTPCtracker.cxx:4190
 AliTPCtracker.cxx:4191
 AliTPCtracker.cxx:4192
 AliTPCtracker.cxx:4193
 AliTPCtracker.cxx:4194
 AliTPCtracker.cxx:4195
 AliTPCtracker.cxx:4196
 AliTPCtracker.cxx:4197
 AliTPCtracker.cxx:4198
 AliTPCtracker.cxx:4199
 AliTPCtracker.cxx:4200
 AliTPCtracker.cxx:4201
 AliTPCtracker.cxx:4202
 AliTPCtracker.cxx:4203
 AliTPCtracker.cxx:4204
 AliTPCtracker.cxx:4205
 AliTPCtracker.cxx:4206
 AliTPCtracker.cxx:4207
 AliTPCtracker.cxx:4208
 AliTPCtracker.cxx:4209
 AliTPCtracker.cxx:4210
 AliTPCtracker.cxx:4211
 AliTPCtracker.cxx:4212
 AliTPCtracker.cxx:4213
 AliTPCtracker.cxx:4214
 AliTPCtracker.cxx:4215
 AliTPCtracker.cxx:4216
 AliTPCtracker.cxx:4217
 AliTPCtracker.cxx:4218
 AliTPCtracker.cxx:4219
 AliTPCtracker.cxx:4220
 AliTPCtracker.cxx:4221
 AliTPCtracker.cxx:4222
 AliTPCtracker.cxx:4223
 AliTPCtracker.cxx:4224
 AliTPCtracker.cxx:4225
 AliTPCtracker.cxx:4226
 AliTPCtracker.cxx:4227
 AliTPCtracker.cxx:4228
 AliTPCtracker.cxx:4229
 AliTPCtracker.cxx:4230
 AliTPCtracker.cxx:4231
 AliTPCtracker.cxx:4232
 AliTPCtracker.cxx:4233
 AliTPCtracker.cxx:4234
 AliTPCtracker.cxx:4235
 AliTPCtracker.cxx:4236
 AliTPCtracker.cxx:4237
 AliTPCtracker.cxx:4238
 AliTPCtracker.cxx:4239
 AliTPCtracker.cxx:4240
 AliTPCtracker.cxx:4241
 AliTPCtracker.cxx:4242
 AliTPCtracker.cxx:4243
 AliTPCtracker.cxx:4244
 AliTPCtracker.cxx:4245
 AliTPCtracker.cxx:4246
 AliTPCtracker.cxx:4247
 AliTPCtracker.cxx:4248
 AliTPCtracker.cxx:4249
 AliTPCtracker.cxx:4250
 AliTPCtracker.cxx:4251
 AliTPCtracker.cxx:4252
 AliTPCtracker.cxx:4253
 AliTPCtracker.cxx:4254
 AliTPCtracker.cxx:4255
 AliTPCtracker.cxx:4256
 AliTPCtracker.cxx:4257
 AliTPCtracker.cxx:4258
 AliTPCtracker.cxx:4259
 AliTPCtracker.cxx:4260
 AliTPCtracker.cxx:4261
 AliTPCtracker.cxx:4262
 AliTPCtracker.cxx:4263
 AliTPCtracker.cxx:4264
 AliTPCtracker.cxx:4265
 AliTPCtracker.cxx:4266
 AliTPCtracker.cxx:4267
 AliTPCtracker.cxx:4268
 AliTPCtracker.cxx:4269
 AliTPCtracker.cxx:4270
 AliTPCtracker.cxx:4271
 AliTPCtracker.cxx:4272
 AliTPCtracker.cxx:4273
 AliTPCtracker.cxx:4274
 AliTPCtracker.cxx:4275
 AliTPCtracker.cxx:4276
 AliTPCtracker.cxx:4277
 AliTPCtracker.cxx:4278
 AliTPCtracker.cxx:4279
 AliTPCtracker.cxx:4280
 AliTPCtracker.cxx:4281
 AliTPCtracker.cxx:4282
 AliTPCtracker.cxx:4283
 AliTPCtracker.cxx:4284
 AliTPCtracker.cxx:4285
 AliTPCtracker.cxx:4286
 AliTPCtracker.cxx:4287
 AliTPCtracker.cxx:4288
 AliTPCtracker.cxx:4289
 AliTPCtracker.cxx:4290
 AliTPCtracker.cxx:4291
 AliTPCtracker.cxx:4292
 AliTPCtracker.cxx:4293
 AliTPCtracker.cxx:4294
 AliTPCtracker.cxx:4295
 AliTPCtracker.cxx:4296
 AliTPCtracker.cxx:4297
 AliTPCtracker.cxx:4298
 AliTPCtracker.cxx:4299
 AliTPCtracker.cxx:4300
 AliTPCtracker.cxx:4301
 AliTPCtracker.cxx:4302
 AliTPCtracker.cxx:4303
 AliTPCtracker.cxx:4304
 AliTPCtracker.cxx:4305
 AliTPCtracker.cxx:4306
 AliTPCtracker.cxx:4307
 AliTPCtracker.cxx:4308
 AliTPCtracker.cxx:4309
 AliTPCtracker.cxx:4310
 AliTPCtracker.cxx:4311
 AliTPCtracker.cxx:4312
 AliTPCtracker.cxx:4313
 AliTPCtracker.cxx:4314
 AliTPCtracker.cxx:4315
 AliTPCtracker.cxx:4316
 AliTPCtracker.cxx:4317
 AliTPCtracker.cxx:4318
 AliTPCtracker.cxx:4319
 AliTPCtracker.cxx:4320
 AliTPCtracker.cxx:4321
 AliTPCtracker.cxx:4322
 AliTPCtracker.cxx:4323
 AliTPCtracker.cxx:4324
 AliTPCtracker.cxx:4325
 AliTPCtracker.cxx:4326
 AliTPCtracker.cxx:4327
 AliTPCtracker.cxx:4328
 AliTPCtracker.cxx:4329
 AliTPCtracker.cxx:4330
 AliTPCtracker.cxx:4331
 AliTPCtracker.cxx:4332
 AliTPCtracker.cxx:4333
 AliTPCtracker.cxx:4334
 AliTPCtracker.cxx:4335
 AliTPCtracker.cxx:4336
 AliTPCtracker.cxx:4337
 AliTPCtracker.cxx:4338
 AliTPCtracker.cxx:4339
 AliTPCtracker.cxx:4340
 AliTPCtracker.cxx:4341
 AliTPCtracker.cxx:4342
 AliTPCtracker.cxx:4343
 AliTPCtracker.cxx:4344
 AliTPCtracker.cxx:4345
 AliTPCtracker.cxx:4346
 AliTPCtracker.cxx:4347
 AliTPCtracker.cxx:4348
 AliTPCtracker.cxx:4349
 AliTPCtracker.cxx:4350
 AliTPCtracker.cxx:4351
 AliTPCtracker.cxx:4352
 AliTPCtracker.cxx:4353
 AliTPCtracker.cxx:4354
 AliTPCtracker.cxx:4355
 AliTPCtracker.cxx:4356
 AliTPCtracker.cxx:4357
 AliTPCtracker.cxx:4358
 AliTPCtracker.cxx:4359
 AliTPCtracker.cxx:4360
 AliTPCtracker.cxx:4361
 AliTPCtracker.cxx:4362
 AliTPCtracker.cxx:4363
 AliTPCtracker.cxx:4364
 AliTPCtracker.cxx:4365
 AliTPCtracker.cxx:4366
 AliTPCtracker.cxx:4367
 AliTPCtracker.cxx:4368
 AliTPCtracker.cxx:4369
 AliTPCtracker.cxx:4370
 AliTPCtracker.cxx:4371
 AliTPCtracker.cxx:4372
 AliTPCtracker.cxx:4373
 AliTPCtracker.cxx:4374
 AliTPCtracker.cxx:4375
 AliTPCtracker.cxx:4376
 AliTPCtracker.cxx:4377
 AliTPCtracker.cxx:4378
 AliTPCtracker.cxx:4379
 AliTPCtracker.cxx:4380
 AliTPCtracker.cxx:4381
 AliTPCtracker.cxx:4382
 AliTPCtracker.cxx:4383
 AliTPCtracker.cxx:4384
 AliTPCtracker.cxx:4385
 AliTPCtracker.cxx:4386
 AliTPCtracker.cxx:4387
 AliTPCtracker.cxx:4388
 AliTPCtracker.cxx:4389
 AliTPCtracker.cxx:4390
 AliTPCtracker.cxx:4391
 AliTPCtracker.cxx:4392
 AliTPCtracker.cxx:4393
 AliTPCtracker.cxx:4394
 AliTPCtracker.cxx:4395
 AliTPCtracker.cxx:4396
 AliTPCtracker.cxx:4397
 AliTPCtracker.cxx:4398
 AliTPCtracker.cxx:4399
 AliTPCtracker.cxx:4400
 AliTPCtracker.cxx:4401
 AliTPCtracker.cxx:4402
 AliTPCtracker.cxx:4403
 AliTPCtracker.cxx:4404
 AliTPCtracker.cxx:4405
 AliTPCtracker.cxx:4406
 AliTPCtracker.cxx:4407
 AliTPCtracker.cxx:4408
 AliTPCtracker.cxx:4409
 AliTPCtracker.cxx:4410
 AliTPCtracker.cxx:4411
 AliTPCtracker.cxx:4412
 AliTPCtracker.cxx:4413
 AliTPCtracker.cxx:4414
 AliTPCtracker.cxx:4415
 AliTPCtracker.cxx:4416
 AliTPCtracker.cxx:4417
 AliTPCtracker.cxx:4418
 AliTPCtracker.cxx:4419
 AliTPCtracker.cxx:4420
 AliTPCtracker.cxx:4421
 AliTPCtracker.cxx:4422
 AliTPCtracker.cxx:4423
 AliTPCtracker.cxx:4424
 AliTPCtracker.cxx:4425
 AliTPCtracker.cxx:4426
 AliTPCtracker.cxx:4427
 AliTPCtracker.cxx:4428
 AliTPCtracker.cxx:4429
 AliTPCtracker.cxx:4430
 AliTPCtracker.cxx:4431
 AliTPCtracker.cxx:4432
 AliTPCtracker.cxx:4433
 AliTPCtracker.cxx:4434
 AliTPCtracker.cxx:4435
 AliTPCtracker.cxx:4436
 AliTPCtracker.cxx:4437
 AliTPCtracker.cxx:4438
 AliTPCtracker.cxx:4439
 AliTPCtracker.cxx:4440
 AliTPCtracker.cxx:4441
 AliTPCtracker.cxx:4442
 AliTPCtracker.cxx:4443
 AliTPCtracker.cxx:4444
 AliTPCtracker.cxx:4445
 AliTPCtracker.cxx:4446
 AliTPCtracker.cxx:4447
 AliTPCtracker.cxx:4448
 AliTPCtracker.cxx:4449
 AliTPCtracker.cxx:4450
 AliTPCtracker.cxx:4451
 AliTPCtracker.cxx:4452
 AliTPCtracker.cxx:4453
 AliTPCtracker.cxx:4454
 AliTPCtracker.cxx:4455
 AliTPCtracker.cxx:4456
 AliTPCtracker.cxx:4457
 AliTPCtracker.cxx:4458
 AliTPCtracker.cxx:4459
 AliTPCtracker.cxx:4460
 AliTPCtracker.cxx:4461
 AliTPCtracker.cxx:4462
 AliTPCtracker.cxx:4463
 AliTPCtracker.cxx:4464
 AliTPCtracker.cxx:4465
 AliTPCtracker.cxx:4466
 AliTPCtracker.cxx:4467
 AliTPCtracker.cxx:4468
 AliTPCtracker.cxx:4469
 AliTPCtracker.cxx:4470
 AliTPCtracker.cxx:4471
 AliTPCtracker.cxx:4472
 AliTPCtracker.cxx:4473
 AliTPCtracker.cxx:4474
 AliTPCtracker.cxx:4475
 AliTPCtracker.cxx:4476
 AliTPCtracker.cxx:4477
 AliTPCtracker.cxx:4478
 AliTPCtracker.cxx:4479
 AliTPCtracker.cxx:4480
 AliTPCtracker.cxx:4481
 AliTPCtracker.cxx:4482
 AliTPCtracker.cxx:4483
 AliTPCtracker.cxx:4484
 AliTPCtracker.cxx:4485
 AliTPCtracker.cxx:4486
 AliTPCtracker.cxx:4487
 AliTPCtracker.cxx:4488
 AliTPCtracker.cxx:4489
 AliTPCtracker.cxx:4490
 AliTPCtracker.cxx:4491
 AliTPCtracker.cxx:4492
 AliTPCtracker.cxx:4493
 AliTPCtracker.cxx:4494
 AliTPCtracker.cxx:4495
 AliTPCtracker.cxx:4496
 AliTPCtracker.cxx:4497
 AliTPCtracker.cxx:4498
 AliTPCtracker.cxx:4499
 AliTPCtracker.cxx:4500
 AliTPCtracker.cxx:4501
 AliTPCtracker.cxx:4502
 AliTPCtracker.cxx:4503
 AliTPCtracker.cxx:4504
 AliTPCtracker.cxx:4505
 AliTPCtracker.cxx:4506
 AliTPCtracker.cxx:4507
 AliTPCtracker.cxx:4508
 AliTPCtracker.cxx:4509
 AliTPCtracker.cxx:4510
 AliTPCtracker.cxx:4511
 AliTPCtracker.cxx:4512
 AliTPCtracker.cxx:4513
 AliTPCtracker.cxx:4514
 AliTPCtracker.cxx:4515
 AliTPCtracker.cxx:4516
 AliTPCtracker.cxx:4517
 AliTPCtracker.cxx:4518
 AliTPCtracker.cxx:4519
 AliTPCtracker.cxx:4520
 AliTPCtracker.cxx:4521
 AliTPCtracker.cxx:4522
 AliTPCtracker.cxx:4523
 AliTPCtracker.cxx:4524
 AliTPCtracker.cxx:4525
 AliTPCtracker.cxx:4526
 AliTPCtracker.cxx:4527
 AliTPCtracker.cxx:4528
 AliTPCtracker.cxx:4529
 AliTPCtracker.cxx:4530
 AliTPCtracker.cxx:4531
 AliTPCtracker.cxx:4532
 AliTPCtracker.cxx:4533
 AliTPCtracker.cxx:4534
 AliTPCtracker.cxx:4535
 AliTPCtracker.cxx:4536
 AliTPCtracker.cxx:4537
 AliTPCtracker.cxx:4538
 AliTPCtracker.cxx:4539
 AliTPCtracker.cxx:4540
 AliTPCtracker.cxx:4541
 AliTPCtracker.cxx:4542
 AliTPCtracker.cxx:4543
 AliTPCtracker.cxx:4544
 AliTPCtracker.cxx:4545
 AliTPCtracker.cxx:4546
 AliTPCtracker.cxx:4547
 AliTPCtracker.cxx:4548
 AliTPCtracker.cxx:4549
 AliTPCtracker.cxx:4550
 AliTPCtracker.cxx:4551
 AliTPCtracker.cxx:4552
 AliTPCtracker.cxx:4553
 AliTPCtracker.cxx:4554
 AliTPCtracker.cxx:4555
 AliTPCtracker.cxx:4556
 AliTPCtracker.cxx:4557
 AliTPCtracker.cxx:4558
 AliTPCtracker.cxx:4559
 AliTPCtracker.cxx:4560
 AliTPCtracker.cxx:4561
 AliTPCtracker.cxx:4562
 AliTPCtracker.cxx:4563
 AliTPCtracker.cxx:4564
 AliTPCtracker.cxx:4565
 AliTPCtracker.cxx:4566
 AliTPCtracker.cxx:4567
 AliTPCtracker.cxx:4568
 AliTPCtracker.cxx:4569
 AliTPCtracker.cxx:4570
 AliTPCtracker.cxx:4571
 AliTPCtracker.cxx:4572
 AliTPCtracker.cxx:4573
 AliTPCtracker.cxx:4574
 AliTPCtracker.cxx:4575
 AliTPCtracker.cxx:4576
 AliTPCtracker.cxx:4577
 AliTPCtracker.cxx:4578
 AliTPCtracker.cxx:4579
 AliTPCtracker.cxx:4580
 AliTPCtracker.cxx:4581
 AliTPCtracker.cxx:4582
 AliTPCtracker.cxx:4583
 AliTPCtracker.cxx:4584
 AliTPCtracker.cxx:4585
 AliTPCtracker.cxx:4586
 AliTPCtracker.cxx:4587
 AliTPCtracker.cxx:4588
 AliTPCtracker.cxx:4589
 AliTPCtracker.cxx:4590
 AliTPCtracker.cxx:4591
 AliTPCtracker.cxx:4592
 AliTPCtracker.cxx:4593
 AliTPCtracker.cxx:4594
 AliTPCtracker.cxx:4595
 AliTPCtracker.cxx:4596
 AliTPCtracker.cxx:4597
 AliTPCtracker.cxx:4598
 AliTPCtracker.cxx:4599
 AliTPCtracker.cxx:4600
 AliTPCtracker.cxx:4601
 AliTPCtracker.cxx:4602
 AliTPCtracker.cxx:4603
 AliTPCtracker.cxx:4604
 AliTPCtracker.cxx:4605
 AliTPCtracker.cxx:4606
 AliTPCtracker.cxx:4607
 AliTPCtracker.cxx:4608
 AliTPCtracker.cxx:4609
 AliTPCtracker.cxx:4610
 AliTPCtracker.cxx:4611
 AliTPCtracker.cxx:4612
 AliTPCtracker.cxx:4613
 AliTPCtracker.cxx:4614
 AliTPCtracker.cxx:4615
 AliTPCtracker.cxx:4616
 AliTPCtracker.cxx:4617
 AliTPCtracker.cxx:4618
 AliTPCtracker.cxx:4619
 AliTPCtracker.cxx:4620
 AliTPCtracker.cxx:4621
 AliTPCtracker.cxx:4622
 AliTPCtracker.cxx:4623
 AliTPCtracker.cxx:4624
 AliTPCtracker.cxx:4625
 AliTPCtracker.cxx:4626
 AliTPCtracker.cxx:4627
 AliTPCtracker.cxx:4628
 AliTPCtracker.cxx:4629
 AliTPCtracker.cxx:4630
 AliTPCtracker.cxx:4631
 AliTPCtracker.cxx:4632
 AliTPCtracker.cxx:4633
 AliTPCtracker.cxx:4634
 AliTPCtracker.cxx:4635
 AliTPCtracker.cxx:4636
 AliTPCtracker.cxx:4637
 AliTPCtracker.cxx:4638
 AliTPCtracker.cxx:4639
 AliTPCtracker.cxx:4640
 AliTPCtracker.cxx:4641
 AliTPCtracker.cxx:4642
 AliTPCtracker.cxx:4643
 AliTPCtracker.cxx:4644
 AliTPCtracker.cxx:4645
 AliTPCtracker.cxx:4646
 AliTPCtracker.cxx:4647
 AliTPCtracker.cxx:4648
 AliTPCtracker.cxx:4649
 AliTPCtracker.cxx:4650
 AliTPCtracker.cxx:4651
 AliTPCtracker.cxx:4652
 AliTPCtracker.cxx:4653
 AliTPCtracker.cxx:4654
 AliTPCtracker.cxx:4655
 AliTPCtracker.cxx:4656
 AliTPCtracker.cxx:4657
 AliTPCtracker.cxx:4658
 AliTPCtracker.cxx:4659
 AliTPCtracker.cxx:4660
 AliTPCtracker.cxx:4661
 AliTPCtracker.cxx:4662
 AliTPCtracker.cxx:4663
 AliTPCtracker.cxx:4664
 AliTPCtracker.cxx:4665
 AliTPCtracker.cxx:4666
 AliTPCtracker.cxx:4667
 AliTPCtracker.cxx:4668
 AliTPCtracker.cxx:4669
 AliTPCtracker.cxx:4670
 AliTPCtracker.cxx:4671
 AliTPCtracker.cxx:4672
 AliTPCtracker.cxx:4673
 AliTPCtracker.cxx:4674
 AliTPCtracker.cxx:4675
 AliTPCtracker.cxx:4676
 AliTPCtracker.cxx:4677
 AliTPCtracker.cxx:4678
 AliTPCtracker.cxx:4679
 AliTPCtracker.cxx:4680
 AliTPCtracker.cxx:4681
 AliTPCtracker.cxx:4682
 AliTPCtracker.cxx:4683
 AliTPCtracker.cxx:4684
 AliTPCtracker.cxx:4685
 AliTPCtracker.cxx:4686
 AliTPCtracker.cxx:4687
 AliTPCtracker.cxx:4688
 AliTPCtracker.cxx:4689
 AliTPCtracker.cxx:4690
 AliTPCtracker.cxx:4691
 AliTPCtracker.cxx:4692
 AliTPCtracker.cxx:4693
 AliTPCtracker.cxx:4694
 AliTPCtracker.cxx:4695
 AliTPCtracker.cxx:4696
 AliTPCtracker.cxx:4697
 AliTPCtracker.cxx:4698
 AliTPCtracker.cxx:4699
 AliTPCtracker.cxx:4700
 AliTPCtracker.cxx:4701
 AliTPCtracker.cxx:4702
 AliTPCtracker.cxx:4703
 AliTPCtracker.cxx:4704
 AliTPCtracker.cxx:4705
 AliTPCtracker.cxx:4706
 AliTPCtracker.cxx:4707
 AliTPCtracker.cxx:4708
 AliTPCtracker.cxx:4709
 AliTPCtracker.cxx:4710
 AliTPCtracker.cxx:4711
 AliTPCtracker.cxx:4712
 AliTPCtracker.cxx:4713
 AliTPCtracker.cxx:4714
 AliTPCtracker.cxx:4715
 AliTPCtracker.cxx:4716
 AliTPCtracker.cxx:4717
 AliTPCtracker.cxx:4718
 AliTPCtracker.cxx:4719
 AliTPCtracker.cxx:4720
 AliTPCtracker.cxx:4721
 AliTPCtracker.cxx:4722
 AliTPCtracker.cxx:4723
 AliTPCtracker.cxx:4724
 AliTPCtracker.cxx:4725
 AliTPCtracker.cxx:4726
 AliTPCtracker.cxx:4727
 AliTPCtracker.cxx:4728
 AliTPCtracker.cxx:4729
 AliTPCtracker.cxx:4730
 AliTPCtracker.cxx:4731
 AliTPCtracker.cxx:4732
 AliTPCtracker.cxx:4733
 AliTPCtracker.cxx:4734
 AliTPCtracker.cxx:4735
 AliTPCtracker.cxx:4736
 AliTPCtracker.cxx:4737
 AliTPCtracker.cxx:4738
 AliTPCtracker.cxx:4739
 AliTPCtracker.cxx:4740
 AliTPCtracker.cxx:4741
 AliTPCtracker.cxx:4742
 AliTPCtracker.cxx:4743
 AliTPCtracker.cxx:4744
 AliTPCtracker.cxx:4745
 AliTPCtracker.cxx:4746
 AliTPCtracker.cxx:4747
 AliTPCtracker.cxx:4748
 AliTPCtracker.cxx:4749
 AliTPCtracker.cxx:4750
 AliTPCtracker.cxx:4751
 AliTPCtracker.cxx:4752
 AliTPCtracker.cxx:4753
 AliTPCtracker.cxx:4754
 AliTPCtracker.cxx:4755
 AliTPCtracker.cxx:4756
 AliTPCtracker.cxx:4757
 AliTPCtracker.cxx:4758
 AliTPCtracker.cxx:4759
 AliTPCtracker.cxx:4760
 AliTPCtracker.cxx:4761
 AliTPCtracker.cxx:4762
 AliTPCtracker.cxx:4763
 AliTPCtracker.cxx:4764
 AliTPCtracker.cxx:4765
 AliTPCtracker.cxx:4766
 AliTPCtracker.cxx:4767
 AliTPCtracker.cxx:4768
 AliTPCtracker.cxx:4769
 AliTPCtracker.cxx:4770
 AliTPCtracker.cxx:4771
 AliTPCtracker.cxx:4772
 AliTPCtracker.cxx:4773
 AliTPCtracker.cxx:4774
 AliTPCtracker.cxx:4775
 AliTPCtracker.cxx:4776
 AliTPCtracker.cxx:4777
 AliTPCtracker.cxx:4778
 AliTPCtracker.cxx:4779
 AliTPCtracker.cxx:4780
 AliTPCtracker.cxx:4781
 AliTPCtracker.cxx:4782
 AliTPCtracker.cxx:4783
 AliTPCtracker.cxx:4784
 AliTPCtracker.cxx:4785
 AliTPCtracker.cxx:4786
 AliTPCtracker.cxx:4787
 AliTPCtracker.cxx:4788
 AliTPCtracker.cxx:4789
 AliTPCtracker.cxx:4790
 AliTPCtracker.cxx:4791
 AliTPCtracker.cxx:4792
 AliTPCtracker.cxx:4793
 AliTPCtracker.cxx:4794
 AliTPCtracker.cxx:4795
 AliTPCtracker.cxx:4796
 AliTPCtracker.cxx:4797
 AliTPCtracker.cxx:4798
 AliTPCtracker.cxx:4799
 AliTPCtracker.cxx:4800
 AliTPCtracker.cxx:4801
 AliTPCtracker.cxx:4802
 AliTPCtracker.cxx:4803
 AliTPCtracker.cxx:4804
 AliTPCtracker.cxx:4805
 AliTPCtracker.cxx:4806
 AliTPCtracker.cxx:4807
 AliTPCtracker.cxx:4808
 AliTPCtracker.cxx:4809
 AliTPCtracker.cxx:4810
 AliTPCtracker.cxx:4811
 AliTPCtracker.cxx:4812
 AliTPCtracker.cxx:4813
 AliTPCtracker.cxx:4814
 AliTPCtracker.cxx:4815
 AliTPCtracker.cxx:4816
 AliTPCtracker.cxx:4817
 AliTPCtracker.cxx:4818
 AliTPCtracker.cxx:4819
 AliTPCtracker.cxx:4820
 AliTPCtracker.cxx:4821
 AliTPCtracker.cxx:4822
 AliTPCtracker.cxx:4823
 AliTPCtracker.cxx:4824
 AliTPCtracker.cxx:4825
 AliTPCtracker.cxx:4826
 AliTPCtracker.cxx:4827
 AliTPCtracker.cxx:4828
 AliTPCtracker.cxx:4829
 AliTPCtracker.cxx:4830
 AliTPCtracker.cxx:4831
 AliTPCtracker.cxx:4832
 AliTPCtracker.cxx:4833
 AliTPCtracker.cxx:4834
 AliTPCtracker.cxx:4835
 AliTPCtracker.cxx:4836
 AliTPCtracker.cxx:4837
 AliTPCtracker.cxx:4838
 AliTPCtracker.cxx:4839
 AliTPCtracker.cxx:4840
 AliTPCtracker.cxx:4841
 AliTPCtracker.cxx:4842
 AliTPCtracker.cxx:4843
 AliTPCtracker.cxx:4844
 AliTPCtracker.cxx:4845
 AliTPCtracker.cxx:4846
 AliTPCtracker.cxx:4847
 AliTPCtracker.cxx:4848
 AliTPCtracker.cxx:4849
 AliTPCtracker.cxx:4850
 AliTPCtracker.cxx:4851
 AliTPCtracker.cxx:4852
 AliTPCtracker.cxx:4853
 AliTPCtracker.cxx:4854
 AliTPCtracker.cxx:4855
 AliTPCtracker.cxx:4856
 AliTPCtracker.cxx:4857
 AliTPCtracker.cxx:4858
 AliTPCtracker.cxx:4859
 AliTPCtracker.cxx:4860
 AliTPCtracker.cxx:4861
 AliTPCtracker.cxx:4862
 AliTPCtracker.cxx:4863
 AliTPCtracker.cxx:4864
 AliTPCtracker.cxx:4865
 AliTPCtracker.cxx:4866
 AliTPCtracker.cxx:4867
 AliTPCtracker.cxx:4868
 AliTPCtracker.cxx:4869
 AliTPCtracker.cxx:4870
 AliTPCtracker.cxx:4871
 AliTPCtracker.cxx:4872
 AliTPCtracker.cxx:4873
 AliTPCtracker.cxx:4874
 AliTPCtracker.cxx:4875
 AliTPCtracker.cxx:4876
 AliTPCtracker.cxx:4877
 AliTPCtracker.cxx:4878
 AliTPCtracker.cxx:4879
 AliTPCtracker.cxx:4880
 AliTPCtracker.cxx:4881
 AliTPCtracker.cxx:4882
 AliTPCtracker.cxx:4883
 AliTPCtracker.cxx:4884
 AliTPCtracker.cxx:4885
 AliTPCtracker.cxx:4886
 AliTPCtracker.cxx:4887
 AliTPCtracker.cxx:4888
 AliTPCtracker.cxx:4889
 AliTPCtracker.cxx:4890
 AliTPCtracker.cxx:4891
 AliTPCtracker.cxx:4892
 AliTPCtracker.cxx:4893
 AliTPCtracker.cxx:4894
 AliTPCtracker.cxx:4895
 AliTPCtracker.cxx:4896
 AliTPCtracker.cxx:4897
 AliTPCtracker.cxx:4898
 AliTPCtracker.cxx:4899
 AliTPCtracker.cxx:4900
 AliTPCtracker.cxx:4901
 AliTPCtracker.cxx:4902
 AliTPCtracker.cxx:4903
 AliTPCtracker.cxx:4904
 AliTPCtracker.cxx:4905
 AliTPCtracker.cxx:4906
 AliTPCtracker.cxx:4907
 AliTPCtracker.cxx:4908
 AliTPCtracker.cxx:4909
 AliTPCtracker.cxx:4910
 AliTPCtracker.cxx:4911
 AliTPCtracker.cxx:4912
 AliTPCtracker.cxx:4913
 AliTPCtracker.cxx:4914
 AliTPCtracker.cxx:4915
 AliTPCtracker.cxx:4916
 AliTPCtracker.cxx:4917
 AliTPCtracker.cxx:4918
 AliTPCtracker.cxx:4919
 AliTPCtracker.cxx:4920
 AliTPCtracker.cxx:4921
 AliTPCtracker.cxx:4922
 AliTPCtracker.cxx:4923
 AliTPCtracker.cxx:4924
 AliTPCtracker.cxx:4925
 AliTPCtracker.cxx:4926
 AliTPCtracker.cxx:4927
 AliTPCtracker.cxx:4928
 AliTPCtracker.cxx:4929
 AliTPCtracker.cxx:4930
 AliTPCtracker.cxx:4931
 AliTPCtracker.cxx:4932
 AliTPCtracker.cxx:4933
 AliTPCtracker.cxx:4934
 AliTPCtracker.cxx:4935
 AliTPCtracker.cxx:4936
 AliTPCtracker.cxx:4937
 AliTPCtracker.cxx:4938
 AliTPCtracker.cxx:4939
 AliTPCtracker.cxx:4940
 AliTPCtracker.cxx:4941
 AliTPCtracker.cxx:4942
 AliTPCtracker.cxx:4943
 AliTPCtracker.cxx:4944
 AliTPCtracker.cxx:4945
 AliTPCtracker.cxx:4946
 AliTPCtracker.cxx:4947
 AliTPCtracker.cxx:4948
 AliTPCtracker.cxx:4949
 AliTPCtracker.cxx:4950
 AliTPCtracker.cxx:4951
 AliTPCtracker.cxx:4952
 AliTPCtracker.cxx:4953
 AliTPCtracker.cxx:4954
 AliTPCtracker.cxx:4955
 AliTPCtracker.cxx:4956
 AliTPCtracker.cxx:4957
 AliTPCtracker.cxx:4958
 AliTPCtracker.cxx:4959
 AliTPCtracker.cxx:4960
 AliTPCtracker.cxx:4961
 AliTPCtracker.cxx:4962
 AliTPCtracker.cxx:4963
 AliTPCtracker.cxx:4964
 AliTPCtracker.cxx:4965
 AliTPCtracker.cxx:4966
 AliTPCtracker.cxx:4967
 AliTPCtracker.cxx:4968
 AliTPCtracker.cxx:4969
 AliTPCtracker.cxx:4970
 AliTPCtracker.cxx:4971
 AliTPCtracker.cxx:4972
 AliTPCtracker.cxx:4973
 AliTPCtracker.cxx:4974
 AliTPCtracker.cxx:4975
 AliTPCtracker.cxx:4976
 AliTPCtracker.cxx:4977
 AliTPCtracker.cxx:4978
 AliTPCtracker.cxx:4979
 AliTPCtracker.cxx:4980
 AliTPCtracker.cxx:4981
 AliTPCtracker.cxx:4982
 AliTPCtracker.cxx:4983
 AliTPCtracker.cxx:4984
 AliTPCtracker.cxx:4985
 AliTPCtracker.cxx:4986
 AliTPCtracker.cxx:4987
 AliTPCtracker.cxx:4988
 AliTPCtracker.cxx:4989
 AliTPCtracker.cxx:4990
 AliTPCtracker.cxx:4991
 AliTPCtracker.cxx:4992
 AliTPCtracker.cxx:4993
 AliTPCtracker.cxx:4994
 AliTPCtracker.cxx:4995
 AliTPCtracker.cxx:4996
 AliTPCtracker.cxx:4997
 AliTPCtracker.cxx:4998
 AliTPCtracker.cxx:4999
 AliTPCtracker.cxx:5000
 AliTPCtracker.cxx:5001
 AliTPCtracker.cxx:5002
 AliTPCtracker.cxx:5003
 AliTPCtracker.cxx:5004
 AliTPCtracker.cxx:5005
 AliTPCtracker.cxx:5006
 AliTPCtracker.cxx:5007
 AliTPCtracker.cxx:5008
 AliTPCtracker.cxx:5009
 AliTPCtracker.cxx:5010
 AliTPCtracker.cxx:5011
 AliTPCtracker.cxx:5012
 AliTPCtracker.cxx:5013
 AliTPCtracker.cxx:5014
 AliTPCtracker.cxx:5015
 AliTPCtracker.cxx:5016
 AliTPCtracker.cxx:5017
 AliTPCtracker.cxx:5018
 AliTPCtracker.cxx:5019
 AliTPCtracker.cxx:5020
 AliTPCtracker.cxx:5021
 AliTPCtracker.cxx:5022
 AliTPCtracker.cxx:5023
 AliTPCtracker.cxx:5024
 AliTPCtracker.cxx:5025
 AliTPCtracker.cxx:5026
 AliTPCtracker.cxx:5027
 AliTPCtracker.cxx:5028
 AliTPCtracker.cxx:5029
 AliTPCtracker.cxx:5030
 AliTPCtracker.cxx:5031
 AliTPCtracker.cxx:5032
 AliTPCtracker.cxx:5033
 AliTPCtracker.cxx:5034
 AliTPCtracker.cxx:5035
 AliTPCtracker.cxx:5036
 AliTPCtracker.cxx:5037
 AliTPCtracker.cxx:5038
 AliTPCtracker.cxx:5039
 AliTPCtracker.cxx:5040
 AliTPCtracker.cxx:5041
 AliTPCtracker.cxx:5042
 AliTPCtracker.cxx:5043
 AliTPCtracker.cxx:5044
 AliTPCtracker.cxx:5045
 AliTPCtracker.cxx:5046
 AliTPCtracker.cxx:5047
 AliTPCtracker.cxx:5048
 AliTPCtracker.cxx:5049
 AliTPCtracker.cxx:5050
 AliTPCtracker.cxx:5051
 AliTPCtracker.cxx:5052
 AliTPCtracker.cxx:5053
 AliTPCtracker.cxx:5054
 AliTPCtracker.cxx:5055
 AliTPCtracker.cxx:5056
 AliTPCtracker.cxx:5057
 AliTPCtracker.cxx:5058
 AliTPCtracker.cxx:5059
 AliTPCtracker.cxx:5060
 AliTPCtracker.cxx:5061
 AliTPCtracker.cxx:5062
 AliTPCtracker.cxx:5063
 AliTPCtracker.cxx:5064
 AliTPCtracker.cxx:5065
 AliTPCtracker.cxx:5066
 AliTPCtracker.cxx:5067
 AliTPCtracker.cxx:5068
 AliTPCtracker.cxx:5069
 AliTPCtracker.cxx:5070
 AliTPCtracker.cxx:5071
 AliTPCtracker.cxx:5072
 AliTPCtracker.cxx:5073
 AliTPCtracker.cxx:5074
 AliTPCtracker.cxx:5075
 AliTPCtracker.cxx:5076
 AliTPCtracker.cxx:5077
 AliTPCtracker.cxx:5078
 AliTPCtracker.cxx:5079
 AliTPCtracker.cxx:5080
 AliTPCtracker.cxx:5081
 AliTPCtracker.cxx:5082
 AliTPCtracker.cxx:5083
 AliTPCtracker.cxx:5084
 AliTPCtracker.cxx:5085
 AliTPCtracker.cxx:5086
 AliTPCtracker.cxx:5087
 AliTPCtracker.cxx:5088
 AliTPCtracker.cxx:5089
 AliTPCtracker.cxx:5090
 AliTPCtracker.cxx:5091
 AliTPCtracker.cxx:5092
 AliTPCtracker.cxx:5093
 AliTPCtracker.cxx:5094
 AliTPCtracker.cxx:5095
 AliTPCtracker.cxx:5096
 AliTPCtracker.cxx:5097
 AliTPCtracker.cxx:5098
 AliTPCtracker.cxx:5099
 AliTPCtracker.cxx:5100
 AliTPCtracker.cxx:5101
 AliTPCtracker.cxx:5102
 AliTPCtracker.cxx:5103
 AliTPCtracker.cxx:5104
 AliTPCtracker.cxx:5105
 AliTPCtracker.cxx:5106
 AliTPCtracker.cxx:5107
 AliTPCtracker.cxx:5108
 AliTPCtracker.cxx:5109
 AliTPCtracker.cxx:5110
 AliTPCtracker.cxx:5111
 AliTPCtracker.cxx:5112
 AliTPCtracker.cxx:5113
 AliTPCtracker.cxx:5114
 AliTPCtracker.cxx:5115
 AliTPCtracker.cxx:5116
 AliTPCtracker.cxx:5117
 AliTPCtracker.cxx:5118
 AliTPCtracker.cxx:5119
 AliTPCtracker.cxx:5120
 AliTPCtracker.cxx:5121
 AliTPCtracker.cxx:5122
 AliTPCtracker.cxx:5123
 AliTPCtracker.cxx:5124
 AliTPCtracker.cxx:5125
 AliTPCtracker.cxx:5126
 AliTPCtracker.cxx:5127
 AliTPCtracker.cxx:5128
 AliTPCtracker.cxx:5129
 AliTPCtracker.cxx:5130
 AliTPCtracker.cxx:5131
 AliTPCtracker.cxx:5132
 AliTPCtracker.cxx:5133
 AliTPCtracker.cxx:5134
 AliTPCtracker.cxx:5135
 AliTPCtracker.cxx:5136
 AliTPCtracker.cxx:5137
 AliTPCtracker.cxx:5138
 AliTPCtracker.cxx:5139
 AliTPCtracker.cxx:5140
 AliTPCtracker.cxx:5141
 AliTPCtracker.cxx:5142
 AliTPCtracker.cxx:5143
 AliTPCtracker.cxx:5144
 AliTPCtracker.cxx:5145
 AliTPCtracker.cxx:5146
 AliTPCtracker.cxx:5147
 AliTPCtracker.cxx:5148
 AliTPCtracker.cxx:5149
 AliTPCtracker.cxx:5150
 AliTPCtracker.cxx:5151
 AliTPCtracker.cxx:5152
 AliTPCtracker.cxx:5153
 AliTPCtracker.cxx:5154
 AliTPCtracker.cxx:5155
 AliTPCtracker.cxx:5156
 AliTPCtracker.cxx:5157
 AliTPCtracker.cxx:5158
 AliTPCtracker.cxx:5159
 AliTPCtracker.cxx:5160
 AliTPCtracker.cxx:5161
 AliTPCtracker.cxx:5162
 AliTPCtracker.cxx:5163
 AliTPCtracker.cxx:5164
 AliTPCtracker.cxx:5165
 AliTPCtracker.cxx:5166
 AliTPCtracker.cxx:5167
 AliTPCtracker.cxx:5168
 AliTPCtracker.cxx:5169
 AliTPCtracker.cxx:5170
 AliTPCtracker.cxx:5171
 AliTPCtracker.cxx:5172
 AliTPCtracker.cxx:5173
 AliTPCtracker.cxx:5174
 AliTPCtracker.cxx:5175
 AliTPCtracker.cxx:5176
 AliTPCtracker.cxx:5177
 AliTPCtracker.cxx:5178
 AliTPCtracker.cxx:5179
 AliTPCtracker.cxx:5180
 AliTPCtracker.cxx:5181
 AliTPCtracker.cxx:5182
 AliTPCtracker.cxx:5183
 AliTPCtracker.cxx:5184
 AliTPCtracker.cxx:5185
 AliTPCtracker.cxx:5186
 AliTPCtracker.cxx:5187
 AliTPCtracker.cxx:5188
 AliTPCtracker.cxx:5189
 AliTPCtracker.cxx:5190
 AliTPCtracker.cxx:5191
 AliTPCtracker.cxx:5192
 AliTPCtracker.cxx:5193
 AliTPCtracker.cxx:5194
 AliTPCtracker.cxx:5195
 AliTPCtracker.cxx:5196
 AliTPCtracker.cxx:5197
 AliTPCtracker.cxx:5198
 AliTPCtracker.cxx:5199
 AliTPCtracker.cxx:5200
 AliTPCtracker.cxx:5201
 AliTPCtracker.cxx:5202
 AliTPCtracker.cxx:5203
 AliTPCtracker.cxx:5204
 AliTPCtracker.cxx:5205
 AliTPCtracker.cxx:5206
 AliTPCtracker.cxx:5207
 AliTPCtracker.cxx:5208
 AliTPCtracker.cxx:5209
 AliTPCtracker.cxx:5210
 AliTPCtracker.cxx:5211
 AliTPCtracker.cxx:5212
 AliTPCtracker.cxx:5213
 AliTPCtracker.cxx:5214
 AliTPCtracker.cxx:5215
 AliTPCtracker.cxx:5216
 AliTPCtracker.cxx:5217
 AliTPCtracker.cxx:5218
 AliTPCtracker.cxx:5219
 AliTPCtracker.cxx:5220
 AliTPCtracker.cxx:5221
 AliTPCtracker.cxx:5222
 AliTPCtracker.cxx:5223
 AliTPCtracker.cxx:5224
 AliTPCtracker.cxx:5225
 AliTPCtracker.cxx:5226
 AliTPCtracker.cxx:5227
 AliTPCtracker.cxx:5228
 AliTPCtracker.cxx:5229
 AliTPCtracker.cxx:5230
 AliTPCtracker.cxx:5231
 AliTPCtracker.cxx:5232
 AliTPCtracker.cxx:5233
 AliTPCtracker.cxx:5234
 AliTPCtracker.cxx:5235
 AliTPCtracker.cxx:5236
 AliTPCtracker.cxx:5237
 AliTPCtracker.cxx:5238
 AliTPCtracker.cxx:5239
 AliTPCtracker.cxx:5240
 AliTPCtracker.cxx:5241
 AliTPCtracker.cxx:5242
 AliTPCtracker.cxx:5243
 AliTPCtracker.cxx:5244
 AliTPCtracker.cxx:5245
 AliTPCtracker.cxx:5246
 AliTPCtracker.cxx:5247
 AliTPCtracker.cxx:5248
 AliTPCtracker.cxx:5249
 AliTPCtracker.cxx:5250
 AliTPCtracker.cxx:5251
 AliTPCtracker.cxx:5252
 AliTPCtracker.cxx:5253
 AliTPCtracker.cxx:5254
 AliTPCtracker.cxx:5255
 AliTPCtracker.cxx:5256
 AliTPCtracker.cxx:5257
 AliTPCtracker.cxx:5258
 AliTPCtracker.cxx:5259
 AliTPCtracker.cxx:5260
 AliTPCtracker.cxx:5261
 AliTPCtracker.cxx:5262
 AliTPCtracker.cxx:5263
 AliTPCtracker.cxx:5264
 AliTPCtracker.cxx:5265
 AliTPCtracker.cxx:5266
 AliTPCtracker.cxx:5267
 AliTPCtracker.cxx:5268
 AliTPCtracker.cxx:5269
 AliTPCtracker.cxx:5270
 AliTPCtracker.cxx:5271
 AliTPCtracker.cxx:5272
 AliTPCtracker.cxx:5273
 AliTPCtracker.cxx:5274
 AliTPCtracker.cxx:5275
 AliTPCtracker.cxx:5276
 AliTPCtracker.cxx:5277
 AliTPCtracker.cxx:5278
 AliTPCtracker.cxx:5279
 AliTPCtracker.cxx:5280
 AliTPCtracker.cxx:5281
 AliTPCtracker.cxx:5282
 AliTPCtracker.cxx:5283
 AliTPCtracker.cxx:5284
 AliTPCtracker.cxx:5285
 AliTPCtracker.cxx:5286
 AliTPCtracker.cxx:5287
 AliTPCtracker.cxx:5288
 AliTPCtracker.cxx:5289
 AliTPCtracker.cxx:5290
 AliTPCtracker.cxx:5291
 AliTPCtracker.cxx:5292
 AliTPCtracker.cxx:5293
 AliTPCtracker.cxx:5294
 AliTPCtracker.cxx:5295
 AliTPCtracker.cxx:5296
 AliTPCtracker.cxx:5297
 AliTPCtracker.cxx:5298
 AliTPCtracker.cxx:5299
 AliTPCtracker.cxx:5300
 AliTPCtracker.cxx:5301
 AliTPCtracker.cxx:5302
 AliTPCtracker.cxx:5303
 AliTPCtracker.cxx:5304
 AliTPCtracker.cxx:5305
 AliTPCtracker.cxx:5306
 AliTPCtracker.cxx:5307
 AliTPCtracker.cxx:5308
 AliTPCtracker.cxx:5309
 AliTPCtracker.cxx:5310
 AliTPCtracker.cxx:5311
 AliTPCtracker.cxx:5312
 AliTPCtracker.cxx:5313
 AliTPCtracker.cxx:5314
 AliTPCtracker.cxx:5315
 AliTPCtracker.cxx:5316
 AliTPCtracker.cxx:5317
 AliTPCtracker.cxx:5318
 AliTPCtracker.cxx:5319
 AliTPCtracker.cxx:5320
 AliTPCtracker.cxx:5321
 AliTPCtracker.cxx:5322
 AliTPCtracker.cxx:5323
 AliTPCtracker.cxx:5324
 AliTPCtracker.cxx:5325
 AliTPCtracker.cxx:5326
 AliTPCtracker.cxx:5327
 AliTPCtracker.cxx:5328
 AliTPCtracker.cxx:5329
 AliTPCtracker.cxx:5330
 AliTPCtracker.cxx:5331
 AliTPCtracker.cxx:5332
 AliTPCtracker.cxx:5333
 AliTPCtracker.cxx:5334
 AliTPCtracker.cxx:5335
 AliTPCtracker.cxx:5336
 AliTPCtracker.cxx:5337
 AliTPCtracker.cxx:5338
 AliTPCtracker.cxx:5339
 AliTPCtracker.cxx:5340
 AliTPCtracker.cxx:5341
 AliTPCtracker.cxx:5342
 AliTPCtracker.cxx:5343
 AliTPCtracker.cxx:5344
 AliTPCtracker.cxx:5345
 AliTPCtracker.cxx:5346
 AliTPCtracker.cxx:5347
 AliTPCtracker.cxx:5348
 AliTPCtracker.cxx:5349
 AliTPCtracker.cxx:5350
 AliTPCtracker.cxx:5351
 AliTPCtracker.cxx:5352
 AliTPCtracker.cxx:5353
 AliTPCtracker.cxx:5354
 AliTPCtracker.cxx:5355
 AliTPCtracker.cxx:5356
 AliTPCtracker.cxx:5357
 AliTPCtracker.cxx:5358
 AliTPCtracker.cxx:5359
 AliTPCtracker.cxx:5360
 AliTPCtracker.cxx:5361
 AliTPCtracker.cxx:5362
 AliTPCtracker.cxx:5363
 AliTPCtracker.cxx:5364
 AliTPCtracker.cxx:5365
 AliTPCtracker.cxx:5366
 AliTPCtracker.cxx:5367
 AliTPCtracker.cxx:5368
 AliTPCtracker.cxx:5369
 AliTPCtracker.cxx:5370
 AliTPCtracker.cxx:5371
 AliTPCtracker.cxx:5372
 AliTPCtracker.cxx:5373
 AliTPCtracker.cxx:5374
 AliTPCtracker.cxx:5375
 AliTPCtracker.cxx:5376
 AliTPCtracker.cxx:5377
 AliTPCtracker.cxx:5378
 AliTPCtracker.cxx:5379
 AliTPCtracker.cxx:5380
 AliTPCtracker.cxx:5381
 AliTPCtracker.cxx:5382
 AliTPCtracker.cxx:5383
 AliTPCtracker.cxx:5384
 AliTPCtracker.cxx:5385
 AliTPCtracker.cxx:5386
 AliTPCtracker.cxx:5387
 AliTPCtracker.cxx:5388
 AliTPCtracker.cxx:5389
 AliTPCtracker.cxx:5390
 AliTPCtracker.cxx:5391
 AliTPCtracker.cxx:5392
 AliTPCtracker.cxx:5393
 AliTPCtracker.cxx:5394
 AliTPCtracker.cxx:5395
 AliTPCtracker.cxx:5396
 AliTPCtracker.cxx:5397
 AliTPCtracker.cxx:5398
 AliTPCtracker.cxx:5399
 AliTPCtracker.cxx:5400
 AliTPCtracker.cxx:5401
 AliTPCtracker.cxx:5402
 AliTPCtracker.cxx:5403
 AliTPCtracker.cxx:5404
 AliTPCtracker.cxx:5405
 AliTPCtracker.cxx:5406
 AliTPCtracker.cxx:5407
 AliTPCtracker.cxx:5408
 AliTPCtracker.cxx:5409
 AliTPCtracker.cxx:5410
 AliTPCtracker.cxx:5411
 AliTPCtracker.cxx:5412
 AliTPCtracker.cxx:5413
 AliTPCtracker.cxx:5414
 AliTPCtracker.cxx:5415
 AliTPCtracker.cxx:5416
 AliTPCtracker.cxx:5417
 AliTPCtracker.cxx:5418
 AliTPCtracker.cxx:5419
 AliTPCtracker.cxx:5420
 AliTPCtracker.cxx:5421
 AliTPCtracker.cxx:5422
 AliTPCtracker.cxx:5423
 AliTPCtracker.cxx:5424
 AliTPCtracker.cxx:5425
 AliTPCtracker.cxx:5426
 AliTPCtracker.cxx:5427
 AliTPCtracker.cxx:5428
 AliTPCtracker.cxx:5429
 AliTPCtracker.cxx:5430
 AliTPCtracker.cxx:5431
 AliTPCtracker.cxx:5432
 AliTPCtracker.cxx:5433
 AliTPCtracker.cxx:5434
 AliTPCtracker.cxx:5435
 AliTPCtracker.cxx:5436
 AliTPCtracker.cxx:5437
 AliTPCtracker.cxx:5438
 AliTPCtracker.cxx:5439
 AliTPCtracker.cxx:5440
 AliTPCtracker.cxx:5441
 AliTPCtracker.cxx:5442
 AliTPCtracker.cxx:5443
 AliTPCtracker.cxx:5444
 AliTPCtracker.cxx:5445
 AliTPCtracker.cxx:5446
 AliTPCtracker.cxx:5447
 AliTPCtracker.cxx:5448
 AliTPCtracker.cxx:5449
 AliTPCtracker.cxx:5450
 AliTPCtracker.cxx:5451
 AliTPCtracker.cxx:5452
 AliTPCtracker.cxx:5453
 AliTPCtracker.cxx:5454
 AliTPCtracker.cxx:5455
 AliTPCtracker.cxx:5456
 AliTPCtracker.cxx:5457
 AliTPCtracker.cxx:5458
 AliTPCtracker.cxx:5459
 AliTPCtracker.cxx:5460
 AliTPCtracker.cxx:5461
 AliTPCtracker.cxx:5462
 AliTPCtracker.cxx:5463
 AliTPCtracker.cxx:5464
 AliTPCtracker.cxx:5465
 AliTPCtracker.cxx:5466
 AliTPCtracker.cxx:5467
 AliTPCtracker.cxx:5468
 AliTPCtracker.cxx:5469
 AliTPCtracker.cxx:5470
 AliTPCtracker.cxx:5471
 AliTPCtracker.cxx:5472
 AliTPCtracker.cxx:5473
 AliTPCtracker.cxx:5474
 AliTPCtracker.cxx:5475
 AliTPCtracker.cxx:5476
 AliTPCtracker.cxx:5477
 AliTPCtracker.cxx:5478
 AliTPCtracker.cxx:5479
 AliTPCtracker.cxx:5480
 AliTPCtracker.cxx:5481
 AliTPCtracker.cxx:5482
 AliTPCtracker.cxx:5483
 AliTPCtracker.cxx:5484
 AliTPCtracker.cxx:5485
 AliTPCtracker.cxx:5486
 AliTPCtracker.cxx:5487
 AliTPCtracker.cxx:5488
 AliTPCtracker.cxx:5489
 AliTPCtracker.cxx:5490
 AliTPCtracker.cxx:5491
 AliTPCtracker.cxx:5492
 AliTPCtracker.cxx:5493
 AliTPCtracker.cxx:5494
 AliTPCtracker.cxx:5495
 AliTPCtracker.cxx:5496
 AliTPCtracker.cxx:5497
 AliTPCtracker.cxx:5498
 AliTPCtracker.cxx:5499
 AliTPCtracker.cxx:5500
 AliTPCtracker.cxx:5501
 AliTPCtracker.cxx:5502
 AliTPCtracker.cxx:5503
 AliTPCtracker.cxx:5504
 AliTPCtracker.cxx:5505
 AliTPCtracker.cxx:5506
 AliTPCtracker.cxx:5507
 AliTPCtracker.cxx:5508
 AliTPCtracker.cxx:5509
 AliTPCtracker.cxx:5510
 AliTPCtracker.cxx:5511
 AliTPCtracker.cxx:5512
 AliTPCtracker.cxx:5513
 AliTPCtracker.cxx:5514
 AliTPCtracker.cxx:5515
 AliTPCtracker.cxx:5516
 AliTPCtracker.cxx:5517
 AliTPCtracker.cxx:5518
 AliTPCtracker.cxx:5519
 AliTPCtracker.cxx:5520
 AliTPCtracker.cxx:5521
 AliTPCtracker.cxx:5522
 AliTPCtracker.cxx:5523
 AliTPCtracker.cxx:5524
 AliTPCtracker.cxx:5525
 AliTPCtracker.cxx:5526
 AliTPCtracker.cxx:5527
 AliTPCtracker.cxx:5528
 AliTPCtracker.cxx:5529
 AliTPCtracker.cxx:5530
 AliTPCtracker.cxx:5531
 AliTPCtracker.cxx:5532
 AliTPCtracker.cxx:5533
 AliTPCtracker.cxx:5534
 AliTPCtracker.cxx:5535
 AliTPCtracker.cxx:5536
 AliTPCtracker.cxx:5537
 AliTPCtracker.cxx:5538
 AliTPCtracker.cxx:5539
 AliTPCtracker.cxx:5540
 AliTPCtracker.cxx:5541
 AliTPCtracker.cxx:5542
 AliTPCtracker.cxx:5543
 AliTPCtracker.cxx:5544
 AliTPCtracker.cxx:5545
 AliTPCtracker.cxx:5546
 AliTPCtracker.cxx:5547
 AliTPCtracker.cxx:5548
 AliTPCtracker.cxx:5549
 AliTPCtracker.cxx:5550
 AliTPCtracker.cxx:5551
 AliTPCtracker.cxx:5552
 AliTPCtracker.cxx:5553
 AliTPCtracker.cxx:5554
 AliTPCtracker.cxx:5555
 AliTPCtracker.cxx:5556
 AliTPCtracker.cxx:5557
 AliTPCtracker.cxx:5558
 AliTPCtracker.cxx:5559
 AliTPCtracker.cxx:5560
 AliTPCtracker.cxx:5561
 AliTPCtracker.cxx:5562
 AliTPCtracker.cxx:5563
 AliTPCtracker.cxx:5564
 AliTPCtracker.cxx:5565
 AliTPCtracker.cxx:5566
 AliTPCtracker.cxx:5567
 AliTPCtracker.cxx:5568
 AliTPCtracker.cxx:5569
 AliTPCtracker.cxx:5570
 AliTPCtracker.cxx:5571
 AliTPCtracker.cxx:5572
 AliTPCtracker.cxx:5573
 AliTPCtracker.cxx:5574
 AliTPCtracker.cxx:5575
 AliTPCtracker.cxx:5576
 AliTPCtracker.cxx:5577
 AliTPCtracker.cxx:5578
 AliTPCtracker.cxx:5579
 AliTPCtracker.cxx:5580
 AliTPCtracker.cxx:5581
 AliTPCtracker.cxx:5582
 AliTPCtracker.cxx:5583
 AliTPCtracker.cxx:5584
 AliTPCtracker.cxx:5585
 AliTPCtracker.cxx:5586
 AliTPCtracker.cxx:5587
 AliTPCtracker.cxx:5588
 AliTPCtracker.cxx:5589
 AliTPCtracker.cxx:5590
 AliTPCtracker.cxx:5591
 AliTPCtracker.cxx:5592
 AliTPCtracker.cxx:5593
 AliTPCtracker.cxx:5594
 AliTPCtracker.cxx:5595
 AliTPCtracker.cxx:5596
 AliTPCtracker.cxx:5597
 AliTPCtracker.cxx:5598
 AliTPCtracker.cxx:5599
 AliTPCtracker.cxx:5600
 AliTPCtracker.cxx:5601
 AliTPCtracker.cxx:5602
 AliTPCtracker.cxx:5603
 AliTPCtracker.cxx:5604
 AliTPCtracker.cxx:5605
 AliTPCtracker.cxx:5606
 AliTPCtracker.cxx:5607
 AliTPCtracker.cxx:5608
 AliTPCtracker.cxx:5609
 AliTPCtracker.cxx:5610
 AliTPCtracker.cxx:5611
 AliTPCtracker.cxx:5612
 AliTPCtracker.cxx:5613
 AliTPCtracker.cxx:5614
 AliTPCtracker.cxx:5615
 AliTPCtracker.cxx:5616
 AliTPCtracker.cxx:5617
 AliTPCtracker.cxx:5618
 AliTPCtracker.cxx:5619
 AliTPCtracker.cxx:5620
 AliTPCtracker.cxx:5621
 AliTPCtracker.cxx:5622
 AliTPCtracker.cxx:5623
 AliTPCtracker.cxx:5624
 AliTPCtracker.cxx:5625
 AliTPCtracker.cxx:5626
 AliTPCtracker.cxx:5627
 AliTPCtracker.cxx:5628
 AliTPCtracker.cxx:5629
 AliTPCtracker.cxx:5630
 AliTPCtracker.cxx:5631
 AliTPCtracker.cxx:5632
 AliTPCtracker.cxx:5633
 AliTPCtracker.cxx:5634
 AliTPCtracker.cxx:5635
 AliTPCtracker.cxx:5636
 AliTPCtracker.cxx:5637
 AliTPCtracker.cxx:5638
 AliTPCtracker.cxx:5639
 AliTPCtracker.cxx:5640
 AliTPCtracker.cxx:5641
 AliTPCtracker.cxx:5642
 AliTPCtracker.cxx:5643
 AliTPCtracker.cxx:5644
 AliTPCtracker.cxx:5645
 AliTPCtracker.cxx:5646
 AliTPCtracker.cxx:5647
 AliTPCtracker.cxx:5648
 AliTPCtracker.cxx:5649
 AliTPCtracker.cxx:5650
 AliTPCtracker.cxx:5651
 AliTPCtracker.cxx:5652
 AliTPCtracker.cxx:5653
 AliTPCtracker.cxx:5654
 AliTPCtracker.cxx:5655
 AliTPCtracker.cxx:5656
 AliTPCtracker.cxx:5657
 AliTPCtracker.cxx:5658
 AliTPCtracker.cxx:5659
 AliTPCtracker.cxx:5660
 AliTPCtracker.cxx:5661
 AliTPCtracker.cxx:5662
 AliTPCtracker.cxx:5663
 AliTPCtracker.cxx:5664
 AliTPCtracker.cxx:5665
 AliTPCtracker.cxx:5666
 AliTPCtracker.cxx:5667
 AliTPCtracker.cxx:5668
 AliTPCtracker.cxx:5669
 AliTPCtracker.cxx:5670
 AliTPCtracker.cxx:5671
 AliTPCtracker.cxx:5672
 AliTPCtracker.cxx:5673
 AliTPCtracker.cxx:5674
 AliTPCtracker.cxx:5675
 AliTPCtracker.cxx:5676
 AliTPCtracker.cxx:5677
 AliTPCtracker.cxx:5678
 AliTPCtracker.cxx:5679
 AliTPCtracker.cxx:5680
 AliTPCtracker.cxx:5681
 AliTPCtracker.cxx:5682
 AliTPCtracker.cxx:5683
 AliTPCtracker.cxx:5684
 AliTPCtracker.cxx:5685
 AliTPCtracker.cxx:5686
 AliTPCtracker.cxx:5687
 AliTPCtracker.cxx:5688
 AliTPCtracker.cxx:5689
 AliTPCtracker.cxx:5690
 AliTPCtracker.cxx:5691
 AliTPCtracker.cxx:5692
 AliTPCtracker.cxx:5693
 AliTPCtracker.cxx:5694
 AliTPCtracker.cxx:5695
 AliTPCtracker.cxx:5696
 AliTPCtracker.cxx:5697
 AliTPCtracker.cxx:5698
 AliTPCtracker.cxx:5699
 AliTPCtracker.cxx:5700
 AliTPCtracker.cxx:5701
 AliTPCtracker.cxx:5702
 AliTPCtracker.cxx:5703
 AliTPCtracker.cxx:5704
 AliTPCtracker.cxx:5705
 AliTPCtracker.cxx:5706
 AliTPCtracker.cxx:5707
 AliTPCtracker.cxx:5708
 AliTPCtracker.cxx:5709
 AliTPCtracker.cxx:5710
 AliTPCtracker.cxx:5711
 AliTPCtracker.cxx:5712
 AliTPCtracker.cxx:5713
 AliTPCtracker.cxx:5714
 AliTPCtracker.cxx:5715
 AliTPCtracker.cxx:5716
 AliTPCtracker.cxx:5717
 AliTPCtracker.cxx:5718
 AliTPCtracker.cxx:5719
 AliTPCtracker.cxx:5720
 AliTPCtracker.cxx:5721
 AliTPCtracker.cxx:5722
 AliTPCtracker.cxx:5723
 AliTPCtracker.cxx:5724
 AliTPCtracker.cxx:5725
 AliTPCtracker.cxx:5726
 AliTPCtracker.cxx:5727
 AliTPCtracker.cxx:5728
 AliTPCtracker.cxx:5729
 AliTPCtracker.cxx:5730
 AliTPCtracker.cxx:5731
 AliTPCtracker.cxx:5732
 AliTPCtracker.cxx:5733
 AliTPCtracker.cxx:5734
 AliTPCtracker.cxx:5735
 AliTPCtracker.cxx:5736
 AliTPCtracker.cxx:5737
 AliTPCtracker.cxx:5738
 AliTPCtracker.cxx:5739
 AliTPCtracker.cxx:5740
 AliTPCtracker.cxx:5741
 AliTPCtracker.cxx:5742
 AliTPCtracker.cxx:5743
 AliTPCtracker.cxx:5744
 AliTPCtracker.cxx:5745
 AliTPCtracker.cxx:5746
 AliTPCtracker.cxx:5747
 AliTPCtracker.cxx:5748
 AliTPCtracker.cxx:5749
 AliTPCtracker.cxx:5750
 AliTPCtracker.cxx:5751
 AliTPCtracker.cxx:5752
 AliTPCtracker.cxx:5753
 AliTPCtracker.cxx:5754
 AliTPCtracker.cxx:5755
 AliTPCtracker.cxx:5756
 AliTPCtracker.cxx:5757
 AliTPCtracker.cxx:5758
 AliTPCtracker.cxx:5759
 AliTPCtracker.cxx:5760
 AliTPCtracker.cxx:5761
 AliTPCtracker.cxx:5762
 AliTPCtracker.cxx:5763
 AliTPCtracker.cxx:5764
 AliTPCtracker.cxx:5765
 AliTPCtracker.cxx:5766
 AliTPCtracker.cxx:5767
 AliTPCtracker.cxx:5768
 AliTPCtracker.cxx:5769
 AliTPCtracker.cxx:5770
 AliTPCtracker.cxx:5771
 AliTPCtracker.cxx:5772
 AliTPCtracker.cxx:5773
 AliTPCtracker.cxx:5774
 AliTPCtracker.cxx:5775
 AliTPCtracker.cxx:5776
 AliTPCtracker.cxx:5777
 AliTPCtracker.cxx:5778
 AliTPCtracker.cxx:5779
 AliTPCtracker.cxx:5780
 AliTPCtracker.cxx:5781
 AliTPCtracker.cxx:5782
 AliTPCtracker.cxx:5783
 AliTPCtracker.cxx:5784
 AliTPCtracker.cxx:5785
 AliTPCtracker.cxx:5786
 AliTPCtracker.cxx:5787
 AliTPCtracker.cxx:5788
 AliTPCtracker.cxx:5789
 AliTPCtracker.cxx:5790
 AliTPCtracker.cxx:5791
 AliTPCtracker.cxx:5792
 AliTPCtracker.cxx:5793
 AliTPCtracker.cxx:5794
 AliTPCtracker.cxx:5795
 AliTPCtracker.cxx:5796
 AliTPCtracker.cxx:5797
 AliTPCtracker.cxx:5798
 AliTPCtracker.cxx:5799
 AliTPCtracker.cxx:5800
 AliTPCtracker.cxx:5801
 AliTPCtracker.cxx:5802
 AliTPCtracker.cxx:5803
 AliTPCtracker.cxx:5804
 AliTPCtracker.cxx:5805
 AliTPCtracker.cxx:5806
 AliTPCtracker.cxx:5807
 AliTPCtracker.cxx:5808
 AliTPCtracker.cxx:5809
 AliTPCtracker.cxx:5810
 AliTPCtracker.cxx:5811
 AliTPCtracker.cxx:5812
 AliTPCtracker.cxx:5813
 AliTPCtracker.cxx:5814
 AliTPCtracker.cxx:5815
 AliTPCtracker.cxx:5816
 AliTPCtracker.cxx:5817
 AliTPCtracker.cxx:5818
 AliTPCtracker.cxx:5819
 AliTPCtracker.cxx:5820
 AliTPCtracker.cxx:5821
 AliTPCtracker.cxx:5822
 AliTPCtracker.cxx:5823
 AliTPCtracker.cxx:5824
 AliTPCtracker.cxx:5825
 AliTPCtracker.cxx:5826
 AliTPCtracker.cxx:5827
 AliTPCtracker.cxx:5828
 AliTPCtracker.cxx:5829
 AliTPCtracker.cxx:5830
 AliTPCtracker.cxx:5831
 AliTPCtracker.cxx:5832
 AliTPCtracker.cxx:5833
 AliTPCtracker.cxx:5834
 AliTPCtracker.cxx:5835
 AliTPCtracker.cxx:5836
 AliTPCtracker.cxx:5837
 AliTPCtracker.cxx:5838
 AliTPCtracker.cxx:5839
 AliTPCtracker.cxx:5840
 AliTPCtracker.cxx:5841
 AliTPCtracker.cxx:5842
 AliTPCtracker.cxx:5843
 AliTPCtracker.cxx:5844
 AliTPCtracker.cxx:5845
 AliTPCtracker.cxx:5846
 AliTPCtracker.cxx:5847
 AliTPCtracker.cxx:5848
 AliTPCtracker.cxx:5849
 AliTPCtracker.cxx:5850
 AliTPCtracker.cxx:5851
 AliTPCtracker.cxx:5852
 AliTPCtracker.cxx:5853
 AliTPCtracker.cxx:5854
 AliTPCtracker.cxx:5855
 AliTPCtracker.cxx:5856
 AliTPCtracker.cxx:5857
 AliTPCtracker.cxx:5858
 AliTPCtracker.cxx:5859
 AliTPCtracker.cxx:5860
 AliTPCtracker.cxx:5861
 AliTPCtracker.cxx:5862
 AliTPCtracker.cxx:5863
 AliTPCtracker.cxx:5864
 AliTPCtracker.cxx:5865
 AliTPCtracker.cxx:5866
 AliTPCtracker.cxx:5867
 AliTPCtracker.cxx:5868
 AliTPCtracker.cxx:5869
 AliTPCtracker.cxx:5870
 AliTPCtracker.cxx:5871
 AliTPCtracker.cxx:5872
 AliTPCtracker.cxx:5873
 AliTPCtracker.cxx:5874
 AliTPCtracker.cxx:5875
 AliTPCtracker.cxx:5876
 AliTPCtracker.cxx:5877
 AliTPCtracker.cxx:5878
 AliTPCtracker.cxx:5879
 AliTPCtracker.cxx:5880
 AliTPCtracker.cxx:5881
 AliTPCtracker.cxx:5882
 AliTPCtracker.cxx:5883
 AliTPCtracker.cxx:5884
 AliTPCtracker.cxx:5885
 AliTPCtracker.cxx:5886
 AliTPCtracker.cxx:5887
 AliTPCtracker.cxx:5888
 AliTPCtracker.cxx:5889
 AliTPCtracker.cxx:5890
 AliTPCtracker.cxx:5891
 AliTPCtracker.cxx:5892
 AliTPCtracker.cxx:5893
 AliTPCtracker.cxx:5894
 AliTPCtracker.cxx:5895
 AliTPCtracker.cxx:5896
 AliTPCtracker.cxx:5897
 AliTPCtracker.cxx:5898
 AliTPCtracker.cxx:5899
 AliTPCtracker.cxx:5900
 AliTPCtracker.cxx:5901
 AliTPCtracker.cxx:5902
 AliTPCtracker.cxx:5903
 AliTPCtracker.cxx:5904
 AliTPCtracker.cxx:5905
 AliTPCtracker.cxx:5906
 AliTPCtracker.cxx:5907
 AliTPCtracker.cxx:5908
 AliTPCtracker.cxx:5909
 AliTPCtracker.cxx:5910
 AliTPCtracker.cxx:5911
 AliTPCtracker.cxx:5912
 AliTPCtracker.cxx:5913
 AliTPCtracker.cxx:5914
 AliTPCtracker.cxx:5915
 AliTPCtracker.cxx:5916
 AliTPCtracker.cxx:5917
 AliTPCtracker.cxx:5918
 AliTPCtracker.cxx:5919
 AliTPCtracker.cxx:5920
 AliTPCtracker.cxx:5921
 AliTPCtracker.cxx:5922
 AliTPCtracker.cxx:5923
 AliTPCtracker.cxx:5924
 AliTPCtracker.cxx:5925
 AliTPCtracker.cxx:5926
 AliTPCtracker.cxx:5927
 AliTPCtracker.cxx:5928
 AliTPCtracker.cxx:5929
 AliTPCtracker.cxx:5930
 AliTPCtracker.cxx:5931
 AliTPCtracker.cxx:5932
 AliTPCtracker.cxx:5933
 AliTPCtracker.cxx:5934
 AliTPCtracker.cxx:5935
 AliTPCtracker.cxx:5936
 AliTPCtracker.cxx:5937
 AliTPCtracker.cxx:5938
 AliTPCtracker.cxx:5939
 AliTPCtracker.cxx:5940
 AliTPCtracker.cxx:5941
 AliTPCtracker.cxx:5942
 AliTPCtracker.cxx:5943
 AliTPCtracker.cxx:5944
 AliTPCtracker.cxx:5945
 AliTPCtracker.cxx:5946
 AliTPCtracker.cxx:5947
 AliTPCtracker.cxx:5948
 AliTPCtracker.cxx:5949
 AliTPCtracker.cxx:5950
 AliTPCtracker.cxx:5951
 AliTPCtracker.cxx:5952
 AliTPCtracker.cxx:5953
 AliTPCtracker.cxx:5954
 AliTPCtracker.cxx:5955
 AliTPCtracker.cxx:5956
 AliTPCtracker.cxx:5957
 AliTPCtracker.cxx:5958
 AliTPCtracker.cxx:5959
 AliTPCtracker.cxx:5960
 AliTPCtracker.cxx:5961
 AliTPCtracker.cxx:5962
 AliTPCtracker.cxx:5963
 AliTPCtracker.cxx:5964
 AliTPCtracker.cxx:5965
 AliTPCtracker.cxx:5966
 AliTPCtracker.cxx:5967
 AliTPCtracker.cxx:5968
 AliTPCtracker.cxx:5969
 AliTPCtracker.cxx:5970
 AliTPCtracker.cxx:5971
 AliTPCtracker.cxx:5972
 AliTPCtracker.cxx:5973
 AliTPCtracker.cxx:5974
 AliTPCtracker.cxx:5975
 AliTPCtracker.cxx:5976
 AliTPCtracker.cxx:5977
 AliTPCtracker.cxx:5978
 AliTPCtracker.cxx:5979
 AliTPCtracker.cxx:5980
 AliTPCtracker.cxx:5981
 AliTPCtracker.cxx:5982
 AliTPCtracker.cxx:5983
 AliTPCtracker.cxx:5984
 AliTPCtracker.cxx:5985
 AliTPCtracker.cxx:5986
 AliTPCtracker.cxx:5987
 AliTPCtracker.cxx:5988
 AliTPCtracker.cxx:5989
 AliTPCtracker.cxx:5990
 AliTPCtracker.cxx:5991
 AliTPCtracker.cxx:5992
 AliTPCtracker.cxx:5993
 AliTPCtracker.cxx:5994
 AliTPCtracker.cxx:5995
 AliTPCtracker.cxx:5996
 AliTPCtracker.cxx:5997
 AliTPCtracker.cxx:5998
 AliTPCtracker.cxx:5999
 AliTPCtracker.cxx:6000
 AliTPCtracker.cxx:6001
 AliTPCtracker.cxx:6002
 AliTPCtracker.cxx:6003
 AliTPCtracker.cxx:6004
 AliTPCtracker.cxx:6005
 AliTPCtracker.cxx:6006
 AliTPCtracker.cxx:6007
 AliTPCtracker.cxx:6008
 AliTPCtracker.cxx:6009
 AliTPCtracker.cxx:6010
 AliTPCtracker.cxx:6011
 AliTPCtracker.cxx:6012
 AliTPCtracker.cxx:6013
 AliTPCtracker.cxx:6014
 AliTPCtracker.cxx:6015
 AliTPCtracker.cxx:6016
 AliTPCtracker.cxx:6017
 AliTPCtracker.cxx:6018
 AliTPCtracker.cxx:6019
 AliTPCtracker.cxx:6020
 AliTPCtracker.cxx:6021
 AliTPCtracker.cxx:6022
 AliTPCtracker.cxx:6023
 AliTPCtracker.cxx:6024
 AliTPCtracker.cxx:6025
 AliTPCtracker.cxx:6026
 AliTPCtracker.cxx:6027
 AliTPCtracker.cxx:6028
 AliTPCtracker.cxx:6029
 AliTPCtracker.cxx:6030
 AliTPCtracker.cxx:6031
 AliTPCtracker.cxx:6032
 AliTPCtracker.cxx:6033
 AliTPCtracker.cxx:6034
 AliTPCtracker.cxx:6035
 AliTPCtracker.cxx:6036
 AliTPCtracker.cxx:6037
 AliTPCtracker.cxx:6038
 AliTPCtracker.cxx:6039
 AliTPCtracker.cxx:6040
 AliTPCtracker.cxx:6041
 AliTPCtracker.cxx:6042
 AliTPCtracker.cxx:6043
 AliTPCtracker.cxx:6044
 AliTPCtracker.cxx:6045
 AliTPCtracker.cxx:6046
 AliTPCtracker.cxx:6047
 AliTPCtracker.cxx:6048
 AliTPCtracker.cxx:6049
 AliTPCtracker.cxx:6050
 AliTPCtracker.cxx:6051
 AliTPCtracker.cxx:6052
 AliTPCtracker.cxx:6053
 AliTPCtracker.cxx:6054
 AliTPCtracker.cxx:6055
 AliTPCtracker.cxx:6056
 AliTPCtracker.cxx:6057
 AliTPCtracker.cxx:6058
 AliTPCtracker.cxx:6059
 AliTPCtracker.cxx:6060
 AliTPCtracker.cxx:6061
 AliTPCtracker.cxx:6062
 AliTPCtracker.cxx:6063
 AliTPCtracker.cxx:6064
 AliTPCtracker.cxx:6065
 AliTPCtracker.cxx:6066
 AliTPCtracker.cxx:6067
 AliTPCtracker.cxx:6068
 AliTPCtracker.cxx:6069
 AliTPCtracker.cxx:6070
 AliTPCtracker.cxx:6071
 AliTPCtracker.cxx:6072
 AliTPCtracker.cxx:6073
 AliTPCtracker.cxx:6074
 AliTPCtracker.cxx:6075
 AliTPCtracker.cxx:6076
 AliTPCtracker.cxx:6077
 AliTPCtracker.cxx:6078
 AliTPCtracker.cxx:6079
 AliTPCtracker.cxx:6080
 AliTPCtracker.cxx:6081
 AliTPCtracker.cxx:6082
 AliTPCtracker.cxx:6083
 AliTPCtracker.cxx:6084
 AliTPCtracker.cxx:6085
 AliTPCtracker.cxx:6086
 AliTPCtracker.cxx:6087
 AliTPCtracker.cxx:6088
 AliTPCtracker.cxx:6089
 AliTPCtracker.cxx:6090
 AliTPCtracker.cxx:6091
 AliTPCtracker.cxx:6092
 AliTPCtracker.cxx:6093
 AliTPCtracker.cxx:6094
 AliTPCtracker.cxx:6095
 AliTPCtracker.cxx:6096
 AliTPCtracker.cxx:6097
 AliTPCtracker.cxx:6098
 AliTPCtracker.cxx:6099
 AliTPCtracker.cxx:6100
 AliTPCtracker.cxx:6101
 AliTPCtracker.cxx:6102
 AliTPCtracker.cxx:6103
 AliTPCtracker.cxx:6104
 AliTPCtracker.cxx:6105
 AliTPCtracker.cxx:6106
 AliTPCtracker.cxx:6107
 AliTPCtracker.cxx:6108
 AliTPCtracker.cxx:6109
 AliTPCtracker.cxx:6110
 AliTPCtracker.cxx:6111
 AliTPCtracker.cxx:6112
 AliTPCtracker.cxx:6113
 AliTPCtracker.cxx:6114
 AliTPCtracker.cxx:6115
 AliTPCtracker.cxx:6116
 AliTPCtracker.cxx:6117
 AliTPCtracker.cxx:6118
 AliTPCtracker.cxx:6119
 AliTPCtracker.cxx:6120
 AliTPCtracker.cxx:6121
 AliTPCtracker.cxx:6122
 AliTPCtracker.cxx:6123
 AliTPCtracker.cxx:6124
 AliTPCtracker.cxx:6125
 AliTPCtracker.cxx:6126
 AliTPCtracker.cxx:6127
 AliTPCtracker.cxx:6128
 AliTPCtracker.cxx:6129
 AliTPCtracker.cxx:6130
 AliTPCtracker.cxx:6131
 AliTPCtracker.cxx:6132
 AliTPCtracker.cxx:6133
 AliTPCtracker.cxx:6134
 AliTPCtracker.cxx:6135
 AliTPCtracker.cxx:6136
 AliTPCtracker.cxx:6137
 AliTPCtracker.cxx:6138
 AliTPCtracker.cxx:6139
 AliTPCtracker.cxx:6140
 AliTPCtracker.cxx:6141
 AliTPCtracker.cxx:6142
 AliTPCtracker.cxx:6143
 AliTPCtracker.cxx:6144
 AliTPCtracker.cxx:6145
 AliTPCtracker.cxx:6146
 AliTPCtracker.cxx:6147
 AliTPCtracker.cxx:6148
 AliTPCtracker.cxx:6149
 AliTPCtracker.cxx:6150
 AliTPCtracker.cxx:6151
 AliTPCtracker.cxx:6152
 AliTPCtracker.cxx:6153
 AliTPCtracker.cxx:6154
 AliTPCtracker.cxx:6155
 AliTPCtracker.cxx:6156
 AliTPCtracker.cxx:6157
 AliTPCtracker.cxx:6158
 AliTPCtracker.cxx:6159
 AliTPCtracker.cxx:6160
 AliTPCtracker.cxx:6161
 AliTPCtracker.cxx:6162
 AliTPCtracker.cxx:6163
 AliTPCtracker.cxx:6164
 AliTPCtracker.cxx:6165
 AliTPCtracker.cxx:6166
 AliTPCtracker.cxx:6167
 AliTPCtracker.cxx:6168
 AliTPCtracker.cxx:6169
 AliTPCtracker.cxx:6170
 AliTPCtracker.cxx:6171
 AliTPCtracker.cxx:6172
 AliTPCtracker.cxx:6173
 AliTPCtracker.cxx:6174
 AliTPCtracker.cxx:6175
 AliTPCtracker.cxx:6176
 AliTPCtracker.cxx:6177
 AliTPCtracker.cxx:6178
 AliTPCtracker.cxx:6179
 AliTPCtracker.cxx:6180
 AliTPCtracker.cxx:6181
 AliTPCtracker.cxx:6182
 AliTPCtracker.cxx:6183
 AliTPCtracker.cxx:6184
 AliTPCtracker.cxx:6185
 AliTPCtracker.cxx:6186
 AliTPCtracker.cxx:6187
 AliTPCtracker.cxx:6188
 AliTPCtracker.cxx:6189
 AliTPCtracker.cxx:6190
 AliTPCtracker.cxx:6191
 AliTPCtracker.cxx:6192
 AliTPCtracker.cxx:6193
 AliTPCtracker.cxx:6194
 AliTPCtracker.cxx:6195
 AliTPCtracker.cxx:6196
 AliTPCtracker.cxx:6197
 AliTPCtracker.cxx:6198
 AliTPCtracker.cxx:6199
 AliTPCtracker.cxx:6200
 AliTPCtracker.cxx:6201
 AliTPCtracker.cxx:6202
 AliTPCtracker.cxx:6203
 AliTPCtracker.cxx:6204
 AliTPCtracker.cxx:6205
 AliTPCtracker.cxx:6206
 AliTPCtracker.cxx:6207
 AliTPCtracker.cxx:6208
 AliTPCtracker.cxx:6209
 AliTPCtracker.cxx:6210
 AliTPCtracker.cxx:6211
 AliTPCtracker.cxx:6212
 AliTPCtracker.cxx:6213
 AliTPCtracker.cxx:6214
 AliTPCtracker.cxx:6215
 AliTPCtracker.cxx:6216
 AliTPCtracker.cxx:6217
 AliTPCtracker.cxx:6218
 AliTPCtracker.cxx:6219
 AliTPCtracker.cxx:6220
 AliTPCtracker.cxx:6221
 AliTPCtracker.cxx:6222
 AliTPCtracker.cxx:6223
 AliTPCtracker.cxx:6224
 AliTPCtracker.cxx:6225
 AliTPCtracker.cxx:6226
 AliTPCtracker.cxx:6227
 AliTPCtracker.cxx:6228
 AliTPCtracker.cxx:6229
 AliTPCtracker.cxx:6230
 AliTPCtracker.cxx:6231
 AliTPCtracker.cxx:6232
 AliTPCtracker.cxx:6233
 AliTPCtracker.cxx:6234
 AliTPCtracker.cxx:6235
 AliTPCtracker.cxx:6236
 AliTPCtracker.cxx:6237
 AliTPCtracker.cxx:6238
 AliTPCtracker.cxx:6239
 AliTPCtracker.cxx:6240
 AliTPCtracker.cxx:6241
 AliTPCtracker.cxx:6242
 AliTPCtracker.cxx:6243
 AliTPCtracker.cxx:6244
 AliTPCtracker.cxx:6245
 AliTPCtracker.cxx:6246
 AliTPCtracker.cxx:6247
 AliTPCtracker.cxx:6248
 AliTPCtracker.cxx:6249
 AliTPCtracker.cxx:6250
 AliTPCtracker.cxx:6251
 AliTPCtracker.cxx:6252
 AliTPCtracker.cxx:6253
 AliTPCtracker.cxx:6254
 AliTPCtracker.cxx:6255
 AliTPCtracker.cxx:6256
 AliTPCtracker.cxx:6257
 AliTPCtracker.cxx:6258
 AliTPCtracker.cxx:6259
 AliTPCtracker.cxx:6260
 AliTPCtracker.cxx:6261
 AliTPCtracker.cxx:6262
 AliTPCtracker.cxx:6263
 AliTPCtracker.cxx:6264
 AliTPCtracker.cxx:6265
 AliTPCtracker.cxx:6266
 AliTPCtracker.cxx:6267
 AliTPCtracker.cxx:6268
 AliTPCtracker.cxx:6269
 AliTPCtracker.cxx:6270
 AliTPCtracker.cxx:6271
 AliTPCtracker.cxx:6272
 AliTPCtracker.cxx:6273
 AliTPCtracker.cxx:6274
 AliTPCtracker.cxx:6275
 AliTPCtracker.cxx:6276
 AliTPCtracker.cxx:6277
 AliTPCtracker.cxx:6278
 AliTPCtracker.cxx:6279
 AliTPCtracker.cxx:6280
 AliTPCtracker.cxx:6281
 AliTPCtracker.cxx:6282
 AliTPCtracker.cxx:6283
 AliTPCtracker.cxx:6284
 AliTPCtracker.cxx:6285
 AliTPCtracker.cxx:6286
 AliTPCtracker.cxx:6287
 AliTPCtracker.cxx:6288
 AliTPCtracker.cxx:6289
 AliTPCtracker.cxx:6290
 AliTPCtracker.cxx:6291
 AliTPCtracker.cxx:6292
 AliTPCtracker.cxx:6293
 AliTPCtracker.cxx:6294
 AliTPCtracker.cxx:6295
 AliTPCtracker.cxx:6296
 AliTPCtracker.cxx:6297
 AliTPCtracker.cxx:6298
 AliTPCtracker.cxx:6299
 AliTPCtracker.cxx:6300
 AliTPCtracker.cxx:6301
 AliTPCtracker.cxx:6302
 AliTPCtracker.cxx:6303
 AliTPCtracker.cxx:6304
 AliTPCtracker.cxx:6305
 AliTPCtracker.cxx:6306
 AliTPCtracker.cxx:6307
 AliTPCtracker.cxx:6308
 AliTPCtracker.cxx:6309
 AliTPCtracker.cxx:6310
 AliTPCtracker.cxx:6311
 AliTPCtracker.cxx:6312
 AliTPCtracker.cxx:6313
 AliTPCtracker.cxx:6314
 AliTPCtracker.cxx:6315
 AliTPCtracker.cxx:6316
 AliTPCtracker.cxx:6317
 AliTPCtracker.cxx:6318
 AliTPCtracker.cxx:6319
 AliTPCtracker.cxx:6320
 AliTPCtracker.cxx:6321
 AliTPCtracker.cxx:6322
 AliTPCtracker.cxx:6323
 AliTPCtracker.cxx:6324
 AliTPCtracker.cxx:6325
 AliTPCtracker.cxx:6326
 AliTPCtracker.cxx:6327
 AliTPCtracker.cxx:6328
 AliTPCtracker.cxx:6329
 AliTPCtracker.cxx:6330
 AliTPCtracker.cxx:6331
 AliTPCtracker.cxx:6332
 AliTPCtracker.cxx:6333
 AliTPCtracker.cxx:6334
 AliTPCtracker.cxx:6335
 AliTPCtracker.cxx:6336
 AliTPCtracker.cxx:6337
 AliTPCtracker.cxx:6338
 AliTPCtracker.cxx:6339
 AliTPCtracker.cxx:6340
 AliTPCtracker.cxx:6341
 AliTPCtracker.cxx:6342
 AliTPCtracker.cxx:6343
 AliTPCtracker.cxx:6344
 AliTPCtracker.cxx:6345
 AliTPCtracker.cxx:6346
 AliTPCtracker.cxx:6347
 AliTPCtracker.cxx:6348
 AliTPCtracker.cxx:6349
 AliTPCtracker.cxx:6350
 AliTPCtracker.cxx:6351
 AliTPCtracker.cxx:6352
 AliTPCtracker.cxx:6353
 AliTPCtracker.cxx:6354
 AliTPCtracker.cxx:6355
 AliTPCtracker.cxx:6356
 AliTPCtracker.cxx:6357
 AliTPCtracker.cxx:6358
 AliTPCtracker.cxx:6359
 AliTPCtracker.cxx:6360
 AliTPCtracker.cxx:6361
 AliTPCtracker.cxx:6362
 AliTPCtracker.cxx:6363
 AliTPCtracker.cxx:6364
 AliTPCtracker.cxx:6365
 AliTPCtracker.cxx:6366
 AliTPCtracker.cxx:6367
 AliTPCtracker.cxx:6368
 AliTPCtracker.cxx:6369
 AliTPCtracker.cxx:6370
 AliTPCtracker.cxx:6371
 AliTPCtracker.cxx:6372
 AliTPCtracker.cxx:6373
 AliTPCtracker.cxx:6374
 AliTPCtracker.cxx:6375
 AliTPCtracker.cxx:6376
 AliTPCtracker.cxx:6377
 AliTPCtracker.cxx:6378
 AliTPCtracker.cxx:6379
 AliTPCtracker.cxx:6380
 AliTPCtracker.cxx:6381
 AliTPCtracker.cxx:6382
 AliTPCtracker.cxx:6383
 AliTPCtracker.cxx:6384
 AliTPCtracker.cxx:6385
 AliTPCtracker.cxx:6386
 AliTPCtracker.cxx:6387
 AliTPCtracker.cxx:6388
 AliTPCtracker.cxx:6389
 AliTPCtracker.cxx:6390
 AliTPCtracker.cxx:6391
 AliTPCtracker.cxx:6392
 AliTPCtracker.cxx:6393
 AliTPCtracker.cxx:6394
 AliTPCtracker.cxx:6395
 AliTPCtracker.cxx:6396
 AliTPCtracker.cxx:6397
 AliTPCtracker.cxx:6398
 AliTPCtracker.cxx:6399
 AliTPCtracker.cxx:6400
 AliTPCtracker.cxx:6401
 AliTPCtracker.cxx:6402
 AliTPCtracker.cxx:6403
 AliTPCtracker.cxx:6404
 AliTPCtracker.cxx:6405
 AliTPCtracker.cxx:6406
 AliTPCtracker.cxx:6407
 AliTPCtracker.cxx:6408
 AliTPCtracker.cxx:6409
 AliTPCtracker.cxx:6410
 AliTPCtracker.cxx:6411
 AliTPCtracker.cxx:6412
 AliTPCtracker.cxx:6413
 AliTPCtracker.cxx:6414
 AliTPCtracker.cxx:6415
 AliTPCtracker.cxx:6416
 AliTPCtracker.cxx:6417
 AliTPCtracker.cxx:6418
 AliTPCtracker.cxx:6419
 AliTPCtracker.cxx:6420
 AliTPCtracker.cxx:6421
 AliTPCtracker.cxx:6422
 AliTPCtracker.cxx:6423
 AliTPCtracker.cxx:6424
 AliTPCtracker.cxx:6425
 AliTPCtracker.cxx:6426
 AliTPCtracker.cxx:6427
 AliTPCtracker.cxx:6428
 AliTPCtracker.cxx:6429
 AliTPCtracker.cxx:6430
 AliTPCtracker.cxx:6431
 AliTPCtracker.cxx:6432
 AliTPCtracker.cxx:6433
 AliTPCtracker.cxx:6434
 AliTPCtracker.cxx:6435
 AliTPCtracker.cxx:6436
 AliTPCtracker.cxx:6437
 AliTPCtracker.cxx:6438
 AliTPCtracker.cxx:6439
 AliTPCtracker.cxx:6440
 AliTPCtracker.cxx:6441
 AliTPCtracker.cxx:6442
 AliTPCtracker.cxx:6443
 AliTPCtracker.cxx:6444
 AliTPCtracker.cxx:6445
 AliTPCtracker.cxx:6446
 AliTPCtracker.cxx:6447
 AliTPCtracker.cxx:6448
 AliTPCtracker.cxx:6449
 AliTPCtracker.cxx:6450
 AliTPCtracker.cxx:6451
 AliTPCtracker.cxx:6452
 AliTPCtracker.cxx:6453
 AliTPCtracker.cxx:6454
 AliTPCtracker.cxx:6455
 AliTPCtracker.cxx:6456
 AliTPCtracker.cxx:6457
 AliTPCtracker.cxx:6458
 AliTPCtracker.cxx:6459
 AliTPCtracker.cxx:6460
 AliTPCtracker.cxx:6461
 AliTPCtracker.cxx:6462
 AliTPCtracker.cxx:6463
 AliTPCtracker.cxx:6464
 AliTPCtracker.cxx:6465
 AliTPCtracker.cxx:6466
 AliTPCtracker.cxx:6467
 AliTPCtracker.cxx:6468
 AliTPCtracker.cxx:6469
 AliTPCtracker.cxx:6470
 AliTPCtracker.cxx:6471
 AliTPCtracker.cxx:6472
 AliTPCtracker.cxx:6473
 AliTPCtracker.cxx:6474
 AliTPCtracker.cxx:6475
 AliTPCtracker.cxx:6476
 AliTPCtracker.cxx:6477
 AliTPCtracker.cxx:6478
 AliTPCtracker.cxx:6479
 AliTPCtracker.cxx:6480
 AliTPCtracker.cxx:6481
 AliTPCtracker.cxx:6482
 AliTPCtracker.cxx:6483
 AliTPCtracker.cxx:6484
 AliTPCtracker.cxx:6485
 AliTPCtracker.cxx:6486
 AliTPCtracker.cxx:6487
 AliTPCtracker.cxx:6488
 AliTPCtracker.cxx:6489
 AliTPCtracker.cxx:6490
 AliTPCtracker.cxx:6491
 AliTPCtracker.cxx:6492
 AliTPCtracker.cxx:6493
 AliTPCtracker.cxx:6494
 AliTPCtracker.cxx:6495
 AliTPCtracker.cxx:6496
 AliTPCtracker.cxx:6497
 AliTPCtracker.cxx:6498
 AliTPCtracker.cxx:6499
 AliTPCtracker.cxx:6500
 AliTPCtracker.cxx:6501
 AliTPCtracker.cxx:6502
 AliTPCtracker.cxx:6503
 AliTPCtracker.cxx:6504
 AliTPCtracker.cxx:6505
 AliTPCtracker.cxx:6506
 AliTPCtracker.cxx:6507
 AliTPCtracker.cxx:6508
 AliTPCtracker.cxx:6509
 AliTPCtracker.cxx:6510
 AliTPCtracker.cxx:6511
 AliTPCtracker.cxx:6512
 AliTPCtracker.cxx:6513
 AliTPCtracker.cxx:6514
 AliTPCtracker.cxx:6515
 AliTPCtracker.cxx:6516
 AliTPCtracker.cxx:6517
 AliTPCtracker.cxx:6518
 AliTPCtracker.cxx:6519
 AliTPCtracker.cxx:6520
 AliTPCtracker.cxx:6521
 AliTPCtracker.cxx:6522
 AliTPCtracker.cxx:6523
 AliTPCtracker.cxx:6524
 AliTPCtracker.cxx:6525
 AliTPCtracker.cxx:6526
 AliTPCtracker.cxx:6527
 AliTPCtracker.cxx:6528
 AliTPCtracker.cxx:6529
 AliTPCtracker.cxx:6530
 AliTPCtracker.cxx:6531
 AliTPCtracker.cxx:6532
 AliTPCtracker.cxx:6533
 AliTPCtracker.cxx:6534
 AliTPCtracker.cxx:6535
 AliTPCtracker.cxx:6536
 AliTPCtracker.cxx:6537
 AliTPCtracker.cxx:6538
 AliTPCtracker.cxx:6539
 AliTPCtracker.cxx:6540
 AliTPCtracker.cxx:6541
 AliTPCtracker.cxx:6542
 AliTPCtracker.cxx:6543
 AliTPCtracker.cxx:6544
 AliTPCtracker.cxx:6545
 AliTPCtracker.cxx:6546
 AliTPCtracker.cxx:6547
 AliTPCtracker.cxx:6548
 AliTPCtracker.cxx:6549
 AliTPCtracker.cxx:6550
 AliTPCtracker.cxx:6551
 AliTPCtracker.cxx:6552
 AliTPCtracker.cxx:6553
 AliTPCtracker.cxx:6554
 AliTPCtracker.cxx:6555
 AliTPCtracker.cxx:6556
 AliTPCtracker.cxx:6557
 AliTPCtracker.cxx:6558
 AliTPCtracker.cxx:6559
 AliTPCtracker.cxx:6560
 AliTPCtracker.cxx:6561
 AliTPCtracker.cxx:6562
 AliTPCtracker.cxx:6563
 AliTPCtracker.cxx:6564
 AliTPCtracker.cxx:6565
 AliTPCtracker.cxx:6566
 AliTPCtracker.cxx:6567
 AliTPCtracker.cxx:6568
 AliTPCtracker.cxx:6569
 AliTPCtracker.cxx:6570
 AliTPCtracker.cxx:6571
 AliTPCtracker.cxx:6572
 AliTPCtracker.cxx:6573
 AliTPCtracker.cxx:6574
 AliTPCtracker.cxx:6575
 AliTPCtracker.cxx:6576
 AliTPCtracker.cxx:6577
 AliTPCtracker.cxx:6578
 AliTPCtracker.cxx:6579
 AliTPCtracker.cxx:6580
 AliTPCtracker.cxx:6581
 AliTPCtracker.cxx:6582
 AliTPCtracker.cxx:6583
 AliTPCtracker.cxx:6584
 AliTPCtracker.cxx:6585
 AliTPCtracker.cxx:6586
 AliTPCtracker.cxx:6587
 AliTPCtracker.cxx:6588
 AliTPCtracker.cxx:6589
 AliTPCtracker.cxx:6590
 AliTPCtracker.cxx:6591
 AliTPCtracker.cxx:6592
 AliTPCtracker.cxx:6593
 AliTPCtracker.cxx:6594
 AliTPCtracker.cxx:6595
 AliTPCtracker.cxx:6596
 AliTPCtracker.cxx:6597
 AliTPCtracker.cxx:6598
 AliTPCtracker.cxx:6599
 AliTPCtracker.cxx:6600
 AliTPCtracker.cxx:6601
 AliTPCtracker.cxx:6602
 AliTPCtracker.cxx:6603
 AliTPCtracker.cxx:6604
 AliTPCtracker.cxx:6605
 AliTPCtracker.cxx:6606
 AliTPCtracker.cxx:6607
 AliTPCtracker.cxx:6608
 AliTPCtracker.cxx:6609
 AliTPCtracker.cxx:6610
 AliTPCtracker.cxx:6611
 AliTPCtracker.cxx:6612
 AliTPCtracker.cxx:6613
 AliTPCtracker.cxx:6614
 AliTPCtracker.cxx:6615
 AliTPCtracker.cxx:6616
 AliTPCtracker.cxx:6617
 AliTPCtracker.cxx:6618
 AliTPCtracker.cxx:6619
 AliTPCtracker.cxx:6620
 AliTPCtracker.cxx:6621
 AliTPCtracker.cxx:6622
 AliTPCtracker.cxx:6623
 AliTPCtracker.cxx:6624
 AliTPCtracker.cxx:6625
 AliTPCtracker.cxx:6626
 AliTPCtracker.cxx:6627
 AliTPCtracker.cxx:6628
 AliTPCtracker.cxx:6629
 AliTPCtracker.cxx:6630
 AliTPCtracker.cxx:6631
 AliTPCtracker.cxx:6632
 AliTPCtracker.cxx:6633
 AliTPCtracker.cxx:6634
 AliTPCtracker.cxx:6635
 AliTPCtracker.cxx:6636
 AliTPCtracker.cxx:6637
 AliTPCtracker.cxx:6638
 AliTPCtracker.cxx:6639
 AliTPCtracker.cxx:6640
 AliTPCtracker.cxx:6641
 AliTPCtracker.cxx:6642
 AliTPCtracker.cxx:6643
 AliTPCtracker.cxx:6644
 AliTPCtracker.cxx:6645
 AliTPCtracker.cxx:6646
 AliTPCtracker.cxx:6647
 AliTPCtracker.cxx:6648
 AliTPCtracker.cxx:6649
 AliTPCtracker.cxx:6650
 AliTPCtracker.cxx:6651
 AliTPCtracker.cxx:6652
 AliTPCtracker.cxx:6653
 AliTPCtracker.cxx:6654
 AliTPCtracker.cxx:6655
 AliTPCtracker.cxx:6656
 AliTPCtracker.cxx:6657
 AliTPCtracker.cxx:6658
 AliTPCtracker.cxx:6659
 AliTPCtracker.cxx:6660
 AliTPCtracker.cxx:6661
 AliTPCtracker.cxx:6662
 AliTPCtracker.cxx:6663
 AliTPCtracker.cxx:6664
 AliTPCtracker.cxx:6665
 AliTPCtracker.cxx:6666
 AliTPCtracker.cxx:6667
 AliTPCtracker.cxx:6668
 AliTPCtracker.cxx:6669
 AliTPCtracker.cxx:6670
 AliTPCtracker.cxx:6671
 AliTPCtracker.cxx:6672
 AliTPCtracker.cxx:6673
 AliTPCtracker.cxx:6674
 AliTPCtracker.cxx:6675
 AliTPCtracker.cxx:6676
 AliTPCtracker.cxx:6677
 AliTPCtracker.cxx:6678
 AliTPCtracker.cxx:6679
 AliTPCtracker.cxx:6680
 AliTPCtracker.cxx:6681
 AliTPCtracker.cxx:6682
 AliTPCtracker.cxx:6683
 AliTPCtracker.cxx:6684
 AliTPCtracker.cxx:6685
 AliTPCtracker.cxx:6686
 AliTPCtracker.cxx:6687
 AliTPCtracker.cxx:6688
 AliTPCtracker.cxx:6689
 AliTPCtracker.cxx:6690
 AliTPCtracker.cxx:6691
 AliTPCtracker.cxx:6692
 AliTPCtracker.cxx:6693
 AliTPCtracker.cxx:6694
 AliTPCtracker.cxx:6695
 AliTPCtracker.cxx:6696
 AliTPCtracker.cxx:6697
 AliTPCtracker.cxx:6698
 AliTPCtracker.cxx:6699
 AliTPCtracker.cxx:6700
 AliTPCtracker.cxx:6701
 AliTPCtracker.cxx:6702
 AliTPCtracker.cxx:6703
 AliTPCtracker.cxx:6704
 AliTPCtracker.cxx:6705
 AliTPCtracker.cxx:6706
 AliTPCtracker.cxx:6707
 AliTPCtracker.cxx:6708
 AliTPCtracker.cxx:6709
 AliTPCtracker.cxx:6710
 AliTPCtracker.cxx:6711
 AliTPCtracker.cxx:6712
 AliTPCtracker.cxx:6713
 AliTPCtracker.cxx:6714
 AliTPCtracker.cxx:6715
 AliTPCtracker.cxx:6716
 AliTPCtracker.cxx:6717
 AliTPCtracker.cxx:6718
 AliTPCtracker.cxx:6719
 AliTPCtracker.cxx:6720
 AliTPCtracker.cxx:6721
 AliTPCtracker.cxx:6722
 AliTPCtracker.cxx:6723
 AliTPCtracker.cxx:6724
 AliTPCtracker.cxx:6725
 AliTPCtracker.cxx:6726
 AliTPCtracker.cxx:6727
 AliTPCtracker.cxx:6728
 AliTPCtracker.cxx:6729
 AliTPCtracker.cxx:6730
 AliTPCtracker.cxx:6731
 AliTPCtracker.cxx:6732
 AliTPCtracker.cxx:6733
 AliTPCtracker.cxx:6734
 AliTPCtracker.cxx:6735
 AliTPCtracker.cxx:6736
 AliTPCtracker.cxx:6737
 AliTPCtracker.cxx:6738
 AliTPCtracker.cxx:6739
 AliTPCtracker.cxx:6740
 AliTPCtracker.cxx:6741
 AliTPCtracker.cxx:6742
 AliTPCtracker.cxx:6743
 AliTPCtracker.cxx:6744
 AliTPCtracker.cxx:6745
 AliTPCtracker.cxx:6746
 AliTPCtracker.cxx:6747
 AliTPCtracker.cxx:6748
 AliTPCtracker.cxx:6749
 AliTPCtracker.cxx:6750
 AliTPCtracker.cxx:6751
 AliTPCtracker.cxx:6752
 AliTPCtracker.cxx:6753
 AliTPCtracker.cxx:6754
 AliTPCtracker.cxx:6755
 AliTPCtracker.cxx:6756
 AliTPCtracker.cxx:6757
 AliTPCtracker.cxx:6758
 AliTPCtracker.cxx:6759
 AliTPCtracker.cxx:6760
 AliTPCtracker.cxx:6761
 AliTPCtracker.cxx:6762
 AliTPCtracker.cxx:6763
 AliTPCtracker.cxx:6764
 AliTPCtracker.cxx:6765
 AliTPCtracker.cxx:6766
 AliTPCtracker.cxx:6767
 AliTPCtracker.cxx:6768
 AliTPCtracker.cxx:6769
 AliTPCtracker.cxx:6770
 AliTPCtracker.cxx:6771
 AliTPCtracker.cxx:6772
 AliTPCtracker.cxx:6773
 AliTPCtracker.cxx:6774
 AliTPCtracker.cxx:6775
 AliTPCtracker.cxx:6776
 AliTPCtracker.cxx:6777
 AliTPCtracker.cxx:6778
 AliTPCtracker.cxx:6779
 AliTPCtracker.cxx:6780
 AliTPCtracker.cxx:6781
 AliTPCtracker.cxx:6782
 AliTPCtracker.cxx:6783
 AliTPCtracker.cxx:6784
 AliTPCtracker.cxx:6785
 AliTPCtracker.cxx:6786
 AliTPCtracker.cxx:6787
 AliTPCtracker.cxx:6788
 AliTPCtracker.cxx:6789
 AliTPCtracker.cxx:6790
 AliTPCtracker.cxx:6791
 AliTPCtracker.cxx:6792
 AliTPCtracker.cxx:6793
 AliTPCtracker.cxx:6794
 AliTPCtracker.cxx:6795
 AliTPCtracker.cxx:6796
 AliTPCtracker.cxx:6797
 AliTPCtracker.cxx:6798
 AliTPCtracker.cxx:6799
 AliTPCtracker.cxx:6800
 AliTPCtracker.cxx:6801
 AliTPCtracker.cxx:6802
 AliTPCtracker.cxx:6803
 AliTPCtracker.cxx:6804
 AliTPCtracker.cxx:6805
 AliTPCtracker.cxx:6806
 AliTPCtracker.cxx:6807
 AliTPCtracker.cxx:6808
 AliTPCtracker.cxx:6809
 AliTPCtracker.cxx:6810
 AliTPCtracker.cxx:6811
 AliTPCtracker.cxx:6812
 AliTPCtracker.cxx:6813
 AliTPCtracker.cxx:6814
 AliTPCtracker.cxx:6815
 AliTPCtracker.cxx:6816
 AliTPCtracker.cxx:6817
 AliTPCtracker.cxx:6818
 AliTPCtracker.cxx:6819
 AliTPCtracker.cxx:6820
 AliTPCtracker.cxx:6821
 AliTPCtracker.cxx:6822
 AliTPCtracker.cxx:6823
 AliTPCtracker.cxx:6824
 AliTPCtracker.cxx:6825
 AliTPCtracker.cxx:6826
 AliTPCtracker.cxx:6827
 AliTPCtracker.cxx:6828
 AliTPCtracker.cxx:6829
 AliTPCtracker.cxx:6830
 AliTPCtracker.cxx:6831
 AliTPCtracker.cxx:6832
 AliTPCtracker.cxx:6833
 AliTPCtracker.cxx:6834
 AliTPCtracker.cxx:6835
 AliTPCtracker.cxx:6836
 AliTPCtracker.cxx:6837
 AliTPCtracker.cxx:6838
 AliTPCtracker.cxx:6839
 AliTPCtracker.cxx:6840
 AliTPCtracker.cxx:6841
 AliTPCtracker.cxx:6842
 AliTPCtracker.cxx:6843
 AliTPCtracker.cxx:6844
 AliTPCtracker.cxx:6845
 AliTPCtracker.cxx:6846
 AliTPCtracker.cxx:6847
 AliTPCtracker.cxx:6848
 AliTPCtracker.cxx:6849
 AliTPCtracker.cxx:6850
 AliTPCtracker.cxx:6851
 AliTPCtracker.cxx:6852
 AliTPCtracker.cxx:6853
 AliTPCtracker.cxx:6854
 AliTPCtracker.cxx:6855
 AliTPCtracker.cxx:6856
 AliTPCtracker.cxx:6857
 AliTPCtracker.cxx:6858
 AliTPCtracker.cxx:6859
 AliTPCtracker.cxx:6860
 AliTPCtracker.cxx:6861
 AliTPCtracker.cxx:6862
 AliTPCtracker.cxx:6863
 AliTPCtracker.cxx:6864
 AliTPCtracker.cxx:6865
 AliTPCtracker.cxx:6866
 AliTPCtracker.cxx:6867
 AliTPCtracker.cxx:6868
 AliTPCtracker.cxx:6869
 AliTPCtracker.cxx:6870
 AliTPCtracker.cxx:6871
 AliTPCtracker.cxx:6872
 AliTPCtracker.cxx:6873
 AliTPCtracker.cxx:6874
 AliTPCtracker.cxx:6875
 AliTPCtracker.cxx:6876
 AliTPCtracker.cxx:6877
 AliTPCtracker.cxx:6878
 AliTPCtracker.cxx:6879
 AliTPCtracker.cxx:6880
 AliTPCtracker.cxx:6881
 AliTPCtracker.cxx:6882
 AliTPCtracker.cxx:6883
 AliTPCtracker.cxx:6884
 AliTPCtracker.cxx:6885
 AliTPCtracker.cxx:6886
 AliTPCtracker.cxx:6887
 AliTPCtracker.cxx:6888
 AliTPCtracker.cxx:6889
 AliTPCtracker.cxx:6890
 AliTPCtracker.cxx:6891
 AliTPCtracker.cxx:6892
 AliTPCtracker.cxx:6893
 AliTPCtracker.cxx:6894
 AliTPCtracker.cxx:6895
 AliTPCtracker.cxx:6896
 AliTPCtracker.cxx:6897
 AliTPCtracker.cxx:6898
 AliTPCtracker.cxx:6899
 AliTPCtracker.cxx:6900
 AliTPCtracker.cxx:6901
 AliTPCtracker.cxx:6902
 AliTPCtracker.cxx:6903
 AliTPCtracker.cxx:6904
 AliTPCtracker.cxx:6905
 AliTPCtracker.cxx:6906
 AliTPCtracker.cxx:6907
 AliTPCtracker.cxx:6908
 AliTPCtracker.cxx:6909
 AliTPCtracker.cxx:6910
 AliTPCtracker.cxx:6911
 AliTPCtracker.cxx:6912
 AliTPCtracker.cxx:6913
 AliTPCtracker.cxx:6914
 AliTPCtracker.cxx:6915
 AliTPCtracker.cxx:6916
 AliTPCtracker.cxx:6917
 AliTPCtracker.cxx:6918
 AliTPCtracker.cxx:6919
 AliTPCtracker.cxx:6920
 AliTPCtracker.cxx:6921
 AliTPCtracker.cxx:6922
 AliTPCtracker.cxx:6923
 AliTPCtracker.cxx:6924
 AliTPCtracker.cxx:6925
 AliTPCtracker.cxx:6926
 AliTPCtracker.cxx:6927
 AliTPCtracker.cxx:6928
 AliTPCtracker.cxx:6929
 AliTPCtracker.cxx:6930
 AliTPCtracker.cxx:6931
 AliTPCtracker.cxx:6932
 AliTPCtracker.cxx:6933
 AliTPCtracker.cxx:6934
 AliTPCtracker.cxx:6935
 AliTPCtracker.cxx:6936
 AliTPCtracker.cxx:6937
 AliTPCtracker.cxx:6938
 AliTPCtracker.cxx:6939
 AliTPCtracker.cxx:6940
 AliTPCtracker.cxx:6941
 AliTPCtracker.cxx:6942
 AliTPCtracker.cxx:6943
 AliTPCtracker.cxx:6944
 AliTPCtracker.cxx:6945
 AliTPCtracker.cxx:6946
 AliTPCtracker.cxx:6947
 AliTPCtracker.cxx:6948
 AliTPCtracker.cxx:6949
 AliTPCtracker.cxx:6950
 AliTPCtracker.cxx:6951
 AliTPCtracker.cxx:6952
 AliTPCtracker.cxx:6953
 AliTPCtracker.cxx:6954
 AliTPCtracker.cxx:6955
 AliTPCtracker.cxx:6956
 AliTPCtracker.cxx:6957
 AliTPCtracker.cxx:6958
 AliTPCtracker.cxx:6959
 AliTPCtracker.cxx:6960
 AliTPCtracker.cxx:6961
 AliTPCtracker.cxx:6962
 AliTPCtracker.cxx:6963
 AliTPCtracker.cxx:6964
 AliTPCtracker.cxx:6965
 AliTPCtracker.cxx:6966
 AliTPCtracker.cxx:6967
 AliTPCtracker.cxx:6968
 AliTPCtracker.cxx:6969
 AliTPCtracker.cxx:6970
 AliTPCtracker.cxx:6971
 AliTPCtracker.cxx:6972
 AliTPCtracker.cxx:6973
 AliTPCtracker.cxx:6974
 AliTPCtracker.cxx:6975
 AliTPCtracker.cxx:6976
 AliTPCtracker.cxx:6977
 AliTPCtracker.cxx:6978
 AliTPCtracker.cxx:6979
 AliTPCtracker.cxx:6980
 AliTPCtracker.cxx:6981
 AliTPCtracker.cxx:6982
 AliTPCtracker.cxx:6983
 AliTPCtracker.cxx:6984
 AliTPCtracker.cxx:6985
 AliTPCtracker.cxx:6986
 AliTPCtracker.cxx:6987
 AliTPCtracker.cxx:6988
 AliTPCtracker.cxx:6989
 AliTPCtracker.cxx:6990
 AliTPCtracker.cxx:6991
 AliTPCtracker.cxx:6992
 AliTPCtracker.cxx:6993
 AliTPCtracker.cxx:6994
 AliTPCtracker.cxx:6995
 AliTPCtracker.cxx:6996
 AliTPCtracker.cxx:6997
 AliTPCtracker.cxx:6998
 AliTPCtracker.cxx:6999
 AliTPCtracker.cxx:7000
 AliTPCtracker.cxx:7001
 AliTPCtracker.cxx:7002
 AliTPCtracker.cxx:7003
 AliTPCtracker.cxx:7004
 AliTPCtracker.cxx:7005
 AliTPCtracker.cxx:7006
 AliTPCtracker.cxx:7007
 AliTPCtracker.cxx:7008
 AliTPCtracker.cxx:7009
 AliTPCtracker.cxx:7010
 AliTPCtracker.cxx:7011
 AliTPCtracker.cxx:7012
 AliTPCtracker.cxx:7013
 AliTPCtracker.cxx:7014
 AliTPCtracker.cxx:7015
 AliTPCtracker.cxx:7016
 AliTPCtracker.cxx:7017
 AliTPCtracker.cxx:7018
 AliTPCtracker.cxx:7019
 AliTPCtracker.cxx:7020
 AliTPCtracker.cxx:7021
 AliTPCtracker.cxx:7022
 AliTPCtracker.cxx:7023
 AliTPCtracker.cxx:7024
 AliTPCtracker.cxx:7025
 AliTPCtracker.cxx:7026
 AliTPCtracker.cxx:7027
 AliTPCtracker.cxx:7028
 AliTPCtracker.cxx:7029
 AliTPCtracker.cxx:7030
 AliTPCtracker.cxx:7031
 AliTPCtracker.cxx:7032
 AliTPCtracker.cxx:7033
 AliTPCtracker.cxx:7034
 AliTPCtracker.cxx:7035
 AliTPCtracker.cxx:7036
 AliTPCtracker.cxx:7037
 AliTPCtracker.cxx:7038
 AliTPCtracker.cxx:7039
 AliTPCtracker.cxx:7040
 AliTPCtracker.cxx:7041
 AliTPCtracker.cxx:7042
 AliTPCtracker.cxx:7043
 AliTPCtracker.cxx:7044
 AliTPCtracker.cxx:7045
 AliTPCtracker.cxx:7046
 AliTPCtracker.cxx:7047
 AliTPCtracker.cxx:7048
 AliTPCtracker.cxx:7049
 AliTPCtracker.cxx:7050
 AliTPCtracker.cxx:7051
 AliTPCtracker.cxx:7052
 AliTPCtracker.cxx:7053
 AliTPCtracker.cxx:7054
 AliTPCtracker.cxx:7055
 AliTPCtracker.cxx:7056
 AliTPCtracker.cxx:7057
 AliTPCtracker.cxx:7058
 AliTPCtracker.cxx:7059
 AliTPCtracker.cxx:7060
 AliTPCtracker.cxx:7061
 AliTPCtracker.cxx:7062
 AliTPCtracker.cxx:7063
 AliTPCtracker.cxx:7064
 AliTPCtracker.cxx:7065
 AliTPCtracker.cxx:7066
 AliTPCtracker.cxx:7067
 AliTPCtracker.cxx:7068
 AliTPCtracker.cxx:7069
 AliTPCtracker.cxx:7070
 AliTPCtracker.cxx:7071
 AliTPCtracker.cxx:7072
 AliTPCtracker.cxx:7073
 AliTPCtracker.cxx:7074
 AliTPCtracker.cxx:7075
 AliTPCtracker.cxx:7076
 AliTPCtracker.cxx:7077
 AliTPCtracker.cxx:7078
 AliTPCtracker.cxx:7079
 AliTPCtracker.cxx:7080
 AliTPCtracker.cxx:7081
 AliTPCtracker.cxx:7082
 AliTPCtracker.cxx:7083
 AliTPCtracker.cxx:7084
 AliTPCtracker.cxx:7085
 AliTPCtracker.cxx:7086
 AliTPCtracker.cxx:7087
 AliTPCtracker.cxx:7088
 AliTPCtracker.cxx:7089
 AliTPCtracker.cxx:7090
 AliTPCtracker.cxx:7091
 AliTPCtracker.cxx:7092
 AliTPCtracker.cxx:7093
 AliTPCtracker.cxx:7094
 AliTPCtracker.cxx:7095
 AliTPCtracker.cxx:7096
 AliTPCtracker.cxx:7097
 AliTPCtracker.cxx:7098
 AliTPCtracker.cxx:7099
 AliTPCtracker.cxx:7100
 AliTPCtracker.cxx:7101
 AliTPCtracker.cxx:7102
 AliTPCtracker.cxx:7103
 AliTPCtracker.cxx:7104
 AliTPCtracker.cxx:7105
 AliTPCtracker.cxx:7106
 AliTPCtracker.cxx:7107
 AliTPCtracker.cxx:7108
 AliTPCtracker.cxx:7109
 AliTPCtracker.cxx:7110
 AliTPCtracker.cxx:7111
 AliTPCtracker.cxx:7112
 AliTPCtracker.cxx:7113
 AliTPCtracker.cxx:7114
 AliTPCtracker.cxx:7115
 AliTPCtracker.cxx:7116
 AliTPCtracker.cxx:7117
 AliTPCtracker.cxx:7118
 AliTPCtracker.cxx:7119
 AliTPCtracker.cxx:7120
 AliTPCtracker.cxx:7121
 AliTPCtracker.cxx:7122
 AliTPCtracker.cxx:7123
 AliTPCtracker.cxx:7124
 AliTPCtracker.cxx:7125
 AliTPCtracker.cxx:7126
 AliTPCtracker.cxx:7127
 AliTPCtracker.cxx:7128
 AliTPCtracker.cxx:7129
 AliTPCtracker.cxx:7130
 AliTPCtracker.cxx:7131
 AliTPCtracker.cxx:7132
 AliTPCtracker.cxx:7133
 AliTPCtracker.cxx:7134
 AliTPCtracker.cxx:7135
 AliTPCtracker.cxx:7136
 AliTPCtracker.cxx:7137
 AliTPCtracker.cxx:7138
 AliTPCtracker.cxx:7139
 AliTPCtracker.cxx:7140
 AliTPCtracker.cxx:7141
 AliTPCtracker.cxx:7142
 AliTPCtracker.cxx:7143
 AliTPCtracker.cxx:7144
 AliTPCtracker.cxx:7145
 AliTPCtracker.cxx:7146
 AliTPCtracker.cxx:7147
 AliTPCtracker.cxx:7148
 AliTPCtracker.cxx:7149
 AliTPCtracker.cxx:7150
 AliTPCtracker.cxx:7151
 AliTPCtracker.cxx:7152
 AliTPCtracker.cxx:7153
 AliTPCtracker.cxx:7154
 AliTPCtracker.cxx:7155
 AliTPCtracker.cxx:7156
 AliTPCtracker.cxx:7157
 AliTPCtracker.cxx:7158
 AliTPCtracker.cxx:7159
 AliTPCtracker.cxx:7160
 AliTPCtracker.cxx:7161
 AliTPCtracker.cxx:7162
 AliTPCtracker.cxx:7163
 AliTPCtracker.cxx:7164
 AliTPCtracker.cxx:7165
 AliTPCtracker.cxx:7166
 AliTPCtracker.cxx:7167
 AliTPCtracker.cxx:7168
 AliTPCtracker.cxx:7169
 AliTPCtracker.cxx:7170
 AliTPCtracker.cxx:7171
 AliTPCtracker.cxx:7172
 AliTPCtracker.cxx:7173
 AliTPCtracker.cxx:7174
 AliTPCtracker.cxx:7175
 AliTPCtracker.cxx:7176
 AliTPCtracker.cxx:7177
 AliTPCtracker.cxx:7178
 AliTPCtracker.cxx:7179
 AliTPCtracker.cxx:7180
 AliTPCtracker.cxx:7181
 AliTPCtracker.cxx:7182
 AliTPCtracker.cxx:7183
 AliTPCtracker.cxx:7184
 AliTPCtracker.cxx:7185
 AliTPCtracker.cxx:7186
 AliTPCtracker.cxx:7187
 AliTPCtracker.cxx:7188
 AliTPCtracker.cxx:7189
 AliTPCtracker.cxx:7190
 AliTPCtracker.cxx:7191
 AliTPCtracker.cxx:7192
 AliTPCtracker.cxx:7193
 AliTPCtracker.cxx:7194
 AliTPCtracker.cxx:7195
 AliTPCtracker.cxx:7196
 AliTPCtracker.cxx:7197
 AliTPCtracker.cxx:7198
 AliTPCtracker.cxx:7199
 AliTPCtracker.cxx:7200
 AliTPCtracker.cxx:7201
 AliTPCtracker.cxx:7202
 AliTPCtracker.cxx:7203
 AliTPCtracker.cxx:7204
 AliTPCtracker.cxx:7205
 AliTPCtracker.cxx:7206
 AliTPCtracker.cxx:7207
 AliTPCtracker.cxx:7208
 AliTPCtracker.cxx:7209
 AliTPCtracker.cxx:7210
 AliTPCtracker.cxx:7211
 AliTPCtracker.cxx:7212
 AliTPCtracker.cxx:7213
 AliTPCtracker.cxx:7214
 AliTPCtracker.cxx:7215
 AliTPCtracker.cxx:7216
 AliTPCtracker.cxx:7217
 AliTPCtracker.cxx:7218
 AliTPCtracker.cxx:7219
 AliTPCtracker.cxx:7220
 AliTPCtracker.cxx:7221
 AliTPCtracker.cxx:7222
 AliTPCtracker.cxx:7223
 AliTPCtracker.cxx:7224
 AliTPCtracker.cxx:7225
 AliTPCtracker.cxx:7226
 AliTPCtracker.cxx:7227
 AliTPCtracker.cxx:7228
 AliTPCtracker.cxx:7229
 AliTPCtracker.cxx:7230
 AliTPCtracker.cxx:7231
 AliTPCtracker.cxx:7232
 AliTPCtracker.cxx:7233
 AliTPCtracker.cxx:7234
 AliTPCtracker.cxx:7235
 AliTPCtracker.cxx:7236
 AliTPCtracker.cxx:7237
 AliTPCtracker.cxx:7238
 AliTPCtracker.cxx:7239
 AliTPCtracker.cxx:7240
 AliTPCtracker.cxx:7241
 AliTPCtracker.cxx:7242
 AliTPCtracker.cxx:7243
 AliTPCtracker.cxx:7244
 AliTPCtracker.cxx:7245
 AliTPCtracker.cxx:7246
 AliTPCtracker.cxx:7247
 AliTPCtracker.cxx:7248
 AliTPCtracker.cxx:7249
 AliTPCtracker.cxx:7250
 AliTPCtracker.cxx:7251
 AliTPCtracker.cxx:7252
 AliTPCtracker.cxx:7253
 AliTPCtracker.cxx:7254
 AliTPCtracker.cxx:7255
 AliTPCtracker.cxx:7256
 AliTPCtracker.cxx:7257
 AliTPCtracker.cxx:7258
 AliTPCtracker.cxx:7259
 AliTPCtracker.cxx:7260
 AliTPCtracker.cxx:7261
 AliTPCtracker.cxx:7262
 AliTPCtracker.cxx:7263
 AliTPCtracker.cxx:7264
 AliTPCtracker.cxx:7265
 AliTPCtracker.cxx:7266
 AliTPCtracker.cxx:7267
 AliTPCtracker.cxx:7268
 AliTPCtracker.cxx:7269
 AliTPCtracker.cxx:7270
 AliTPCtracker.cxx:7271
 AliTPCtracker.cxx:7272
 AliTPCtracker.cxx:7273
 AliTPCtracker.cxx:7274
 AliTPCtracker.cxx:7275
 AliTPCtracker.cxx:7276
 AliTPCtracker.cxx:7277
 AliTPCtracker.cxx:7278
 AliTPCtracker.cxx:7279
 AliTPCtracker.cxx:7280
 AliTPCtracker.cxx:7281
 AliTPCtracker.cxx:7282
 AliTPCtracker.cxx:7283
 AliTPCtracker.cxx:7284
 AliTPCtracker.cxx:7285
 AliTPCtracker.cxx:7286
 AliTPCtracker.cxx:7287
 AliTPCtracker.cxx:7288
 AliTPCtracker.cxx:7289
 AliTPCtracker.cxx:7290
 AliTPCtracker.cxx:7291
 AliTPCtracker.cxx:7292
 AliTPCtracker.cxx:7293
 AliTPCtracker.cxx:7294
 AliTPCtracker.cxx:7295
 AliTPCtracker.cxx:7296
 AliTPCtracker.cxx:7297
 AliTPCtracker.cxx:7298
 AliTPCtracker.cxx:7299
 AliTPCtracker.cxx:7300
 AliTPCtracker.cxx:7301
 AliTPCtracker.cxx:7302
 AliTPCtracker.cxx:7303
 AliTPCtracker.cxx:7304
 AliTPCtracker.cxx:7305
 AliTPCtracker.cxx:7306
 AliTPCtracker.cxx:7307
 AliTPCtracker.cxx:7308
 AliTPCtracker.cxx:7309
 AliTPCtracker.cxx:7310
 AliTPCtracker.cxx:7311
 AliTPCtracker.cxx:7312
 AliTPCtracker.cxx:7313
 AliTPCtracker.cxx:7314
 AliTPCtracker.cxx:7315
 AliTPCtracker.cxx:7316
 AliTPCtracker.cxx:7317
 AliTPCtracker.cxx:7318
 AliTPCtracker.cxx:7319
 AliTPCtracker.cxx:7320
 AliTPCtracker.cxx:7321
 AliTPCtracker.cxx:7322
 AliTPCtracker.cxx:7323
 AliTPCtracker.cxx:7324
 AliTPCtracker.cxx:7325
 AliTPCtracker.cxx:7326
 AliTPCtracker.cxx:7327
 AliTPCtracker.cxx:7328
 AliTPCtracker.cxx:7329
 AliTPCtracker.cxx:7330
 AliTPCtracker.cxx:7331
 AliTPCtracker.cxx:7332
 AliTPCtracker.cxx:7333
 AliTPCtracker.cxx:7334
 AliTPCtracker.cxx:7335
 AliTPCtracker.cxx:7336
 AliTPCtracker.cxx:7337
 AliTPCtracker.cxx:7338
 AliTPCtracker.cxx:7339
 AliTPCtracker.cxx:7340
 AliTPCtracker.cxx:7341
 AliTPCtracker.cxx:7342
 AliTPCtracker.cxx:7343
 AliTPCtracker.cxx:7344
 AliTPCtracker.cxx:7345
 AliTPCtracker.cxx:7346
 AliTPCtracker.cxx:7347
 AliTPCtracker.cxx:7348
 AliTPCtracker.cxx:7349
 AliTPCtracker.cxx:7350
 AliTPCtracker.cxx:7351
 AliTPCtracker.cxx:7352
 AliTPCtracker.cxx:7353
 AliTPCtracker.cxx:7354
 AliTPCtracker.cxx:7355
 AliTPCtracker.cxx:7356
 AliTPCtracker.cxx:7357
 AliTPCtracker.cxx:7358
 AliTPCtracker.cxx:7359
 AliTPCtracker.cxx:7360
 AliTPCtracker.cxx:7361
 AliTPCtracker.cxx:7362
 AliTPCtracker.cxx:7363
 AliTPCtracker.cxx:7364
 AliTPCtracker.cxx:7365
 AliTPCtracker.cxx:7366
 AliTPCtracker.cxx:7367
 AliTPCtracker.cxx:7368
 AliTPCtracker.cxx:7369
 AliTPCtracker.cxx:7370
 AliTPCtracker.cxx:7371
 AliTPCtracker.cxx:7372
 AliTPCtracker.cxx:7373
 AliTPCtracker.cxx:7374
 AliTPCtracker.cxx:7375
 AliTPCtracker.cxx:7376
 AliTPCtracker.cxx:7377
 AliTPCtracker.cxx:7378
 AliTPCtracker.cxx:7379
 AliTPCtracker.cxx:7380
 AliTPCtracker.cxx:7381
 AliTPCtracker.cxx:7382
 AliTPCtracker.cxx:7383
 AliTPCtracker.cxx:7384
 AliTPCtracker.cxx:7385
 AliTPCtracker.cxx:7386
 AliTPCtracker.cxx:7387
 AliTPCtracker.cxx:7388
 AliTPCtracker.cxx:7389
 AliTPCtracker.cxx:7390
 AliTPCtracker.cxx:7391
 AliTPCtracker.cxx:7392
 AliTPCtracker.cxx:7393
 AliTPCtracker.cxx:7394
 AliTPCtracker.cxx:7395
 AliTPCtracker.cxx:7396
 AliTPCtracker.cxx:7397
 AliTPCtracker.cxx:7398
 AliTPCtracker.cxx:7399
 AliTPCtracker.cxx:7400
 AliTPCtracker.cxx:7401
 AliTPCtracker.cxx:7402
 AliTPCtracker.cxx:7403
 AliTPCtracker.cxx:7404
 AliTPCtracker.cxx:7405
 AliTPCtracker.cxx:7406
 AliTPCtracker.cxx:7407
 AliTPCtracker.cxx:7408
 AliTPCtracker.cxx:7409
 AliTPCtracker.cxx:7410
 AliTPCtracker.cxx:7411
 AliTPCtracker.cxx:7412
 AliTPCtracker.cxx:7413
 AliTPCtracker.cxx:7414
 AliTPCtracker.cxx:7415
 AliTPCtracker.cxx:7416
 AliTPCtracker.cxx:7417
 AliTPCtracker.cxx:7418
 AliTPCtracker.cxx:7419
 AliTPCtracker.cxx:7420
 AliTPCtracker.cxx:7421
 AliTPCtracker.cxx:7422
 AliTPCtracker.cxx:7423
 AliTPCtracker.cxx:7424
 AliTPCtracker.cxx:7425
 AliTPCtracker.cxx:7426
 AliTPCtracker.cxx:7427
 AliTPCtracker.cxx:7428
 AliTPCtracker.cxx:7429
 AliTPCtracker.cxx:7430
 AliTPCtracker.cxx:7431
 AliTPCtracker.cxx:7432
 AliTPCtracker.cxx:7433
 AliTPCtracker.cxx:7434
 AliTPCtracker.cxx:7435
 AliTPCtracker.cxx:7436
 AliTPCtracker.cxx:7437
 AliTPCtracker.cxx:7438
 AliTPCtracker.cxx:7439
 AliTPCtracker.cxx:7440
 AliTPCtracker.cxx:7441
 AliTPCtracker.cxx:7442
 AliTPCtracker.cxx:7443
 AliTPCtracker.cxx:7444
 AliTPCtracker.cxx:7445
 AliTPCtracker.cxx:7446
 AliTPCtracker.cxx:7447
 AliTPCtracker.cxx:7448
 AliTPCtracker.cxx:7449
 AliTPCtracker.cxx:7450
 AliTPCtracker.cxx:7451
 AliTPCtracker.cxx:7452
 AliTPCtracker.cxx:7453
 AliTPCtracker.cxx:7454
 AliTPCtracker.cxx:7455
 AliTPCtracker.cxx:7456
 AliTPCtracker.cxx:7457
 AliTPCtracker.cxx:7458
 AliTPCtracker.cxx:7459
 AliTPCtracker.cxx:7460
 AliTPCtracker.cxx:7461
 AliTPCtracker.cxx:7462
 AliTPCtracker.cxx:7463
 AliTPCtracker.cxx:7464
 AliTPCtracker.cxx:7465
 AliTPCtracker.cxx:7466
 AliTPCtracker.cxx:7467
 AliTPCtracker.cxx:7468
 AliTPCtracker.cxx:7469
 AliTPCtracker.cxx:7470
 AliTPCtracker.cxx:7471
 AliTPCtracker.cxx:7472
 AliTPCtracker.cxx:7473
 AliTPCtracker.cxx:7474
 AliTPCtracker.cxx:7475
 AliTPCtracker.cxx:7476
 AliTPCtracker.cxx:7477
 AliTPCtracker.cxx:7478
 AliTPCtracker.cxx:7479
 AliTPCtracker.cxx:7480
 AliTPCtracker.cxx:7481
 AliTPCtracker.cxx:7482
 AliTPCtracker.cxx:7483
 AliTPCtracker.cxx:7484
 AliTPCtracker.cxx:7485
 AliTPCtracker.cxx:7486
 AliTPCtracker.cxx:7487
 AliTPCtracker.cxx:7488
 AliTPCtracker.cxx:7489
 AliTPCtracker.cxx:7490
 AliTPCtracker.cxx:7491
 AliTPCtracker.cxx:7492
 AliTPCtracker.cxx:7493
 AliTPCtracker.cxx:7494
 AliTPCtracker.cxx:7495
 AliTPCtracker.cxx:7496
 AliTPCtracker.cxx:7497
 AliTPCtracker.cxx:7498
 AliTPCtracker.cxx:7499
 AliTPCtracker.cxx:7500
 AliTPCtracker.cxx:7501
 AliTPCtracker.cxx:7502
 AliTPCtracker.cxx:7503
 AliTPCtracker.cxx:7504
 AliTPCtracker.cxx:7505
 AliTPCtracker.cxx:7506
 AliTPCtracker.cxx:7507
 AliTPCtracker.cxx:7508
 AliTPCtracker.cxx:7509
 AliTPCtracker.cxx:7510
 AliTPCtracker.cxx:7511
 AliTPCtracker.cxx:7512
 AliTPCtracker.cxx:7513
 AliTPCtracker.cxx:7514
 AliTPCtracker.cxx:7515
 AliTPCtracker.cxx:7516
 AliTPCtracker.cxx:7517
 AliTPCtracker.cxx:7518
 AliTPCtracker.cxx:7519
 AliTPCtracker.cxx:7520
 AliTPCtracker.cxx:7521
 AliTPCtracker.cxx:7522
 AliTPCtracker.cxx:7523
 AliTPCtracker.cxx:7524
 AliTPCtracker.cxx:7525
 AliTPCtracker.cxx:7526
 AliTPCtracker.cxx:7527
 AliTPCtracker.cxx:7528
 AliTPCtracker.cxx:7529
 AliTPCtracker.cxx:7530
 AliTPCtracker.cxx:7531
 AliTPCtracker.cxx:7532
 AliTPCtracker.cxx:7533
 AliTPCtracker.cxx:7534
 AliTPCtracker.cxx:7535
 AliTPCtracker.cxx:7536
 AliTPCtracker.cxx:7537
 AliTPCtracker.cxx:7538
 AliTPCtracker.cxx:7539
 AliTPCtracker.cxx:7540
 AliTPCtracker.cxx:7541
 AliTPCtracker.cxx:7542
 AliTPCtracker.cxx:7543
 AliTPCtracker.cxx:7544
 AliTPCtracker.cxx:7545
 AliTPCtracker.cxx:7546
 AliTPCtracker.cxx:7547
 AliTPCtracker.cxx:7548
 AliTPCtracker.cxx:7549
 AliTPCtracker.cxx:7550
 AliTPCtracker.cxx:7551
 AliTPCtracker.cxx:7552
 AliTPCtracker.cxx:7553
 AliTPCtracker.cxx:7554
 AliTPCtracker.cxx:7555
 AliTPCtracker.cxx:7556
 AliTPCtracker.cxx:7557
 AliTPCtracker.cxx:7558
 AliTPCtracker.cxx:7559
 AliTPCtracker.cxx:7560
 AliTPCtracker.cxx:7561
 AliTPCtracker.cxx:7562
 AliTPCtracker.cxx:7563
 AliTPCtracker.cxx:7564
 AliTPCtracker.cxx:7565
 AliTPCtracker.cxx:7566
 AliTPCtracker.cxx:7567
 AliTPCtracker.cxx:7568
 AliTPCtracker.cxx:7569
 AliTPCtracker.cxx:7570
 AliTPCtracker.cxx:7571
 AliTPCtracker.cxx:7572
 AliTPCtracker.cxx:7573
 AliTPCtracker.cxx:7574
 AliTPCtracker.cxx:7575
 AliTPCtracker.cxx:7576
 AliTPCtracker.cxx:7577
 AliTPCtracker.cxx:7578
 AliTPCtracker.cxx:7579
 AliTPCtracker.cxx:7580
 AliTPCtracker.cxx:7581
 AliTPCtracker.cxx:7582
 AliTPCtracker.cxx:7583
 AliTPCtracker.cxx:7584
 AliTPCtracker.cxx:7585
 AliTPCtracker.cxx:7586
 AliTPCtracker.cxx:7587
 AliTPCtracker.cxx:7588
 AliTPCtracker.cxx:7589
 AliTPCtracker.cxx:7590
 AliTPCtracker.cxx:7591
 AliTPCtracker.cxx:7592
 AliTPCtracker.cxx:7593
 AliTPCtracker.cxx:7594
 AliTPCtracker.cxx:7595
 AliTPCtracker.cxx:7596
 AliTPCtracker.cxx:7597
 AliTPCtracker.cxx:7598
 AliTPCtracker.cxx:7599
 AliTPCtracker.cxx:7600
 AliTPCtracker.cxx:7601
 AliTPCtracker.cxx:7602
 AliTPCtracker.cxx:7603
 AliTPCtracker.cxx:7604
 AliTPCtracker.cxx:7605
 AliTPCtracker.cxx:7606
 AliTPCtracker.cxx:7607
 AliTPCtracker.cxx:7608
 AliTPCtracker.cxx:7609
 AliTPCtracker.cxx:7610
 AliTPCtracker.cxx:7611
 AliTPCtracker.cxx:7612
 AliTPCtracker.cxx:7613
 AliTPCtracker.cxx:7614
 AliTPCtracker.cxx:7615
 AliTPCtracker.cxx:7616
 AliTPCtracker.cxx:7617
 AliTPCtracker.cxx:7618
 AliTPCtracker.cxx:7619
 AliTPCtracker.cxx:7620
 AliTPCtracker.cxx:7621
 AliTPCtracker.cxx:7622
 AliTPCtracker.cxx:7623
 AliTPCtracker.cxx:7624
 AliTPCtracker.cxx:7625
 AliTPCtracker.cxx:7626
 AliTPCtracker.cxx:7627
 AliTPCtracker.cxx:7628
 AliTPCtracker.cxx:7629
 AliTPCtracker.cxx:7630
 AliTPCtracker.cxx:7631
 AliTPCtracker.cxx:7632
 AliTPCtracker.cxx:7633
 AliTPCtracker.cxx:7634
 AliTPCtracker.cxx:7635
 AliTPCtracker.cxx:7636
 AliTPCtracker.cxx:7637
 AliTPCtracker.cxx:7638
 AliTPCtracker.cxx:7639
 AliTPCtracker.cxx:7640
 AliTPCtracker.cxx:7641
 AliTPCtracker.cxx:7642
 AliTPCtracker.cxx:7643
 AliTPCtracker.cxx:7644
 AliTPCtracker.cxx:7645
 AliTPCtracker.cxx:7646
 AliTPCtracker.cxx:7647
 AliTPCtracker.cxx:7648
 AliTPCtracker.cxx:7649
 AliTPCtracker.cxx:7650
 AliTPCtracker.cxx:7651
 AliTPCtracker.cxx:7652
 AliTPCtracker.cxx:7653
 AliTPCtracker.cxx:7654
 AliTPCtracker.cxx:7655
 AliTPCtracker.cxx:7656
 AliTPCtracker.cxx:7657
 AliTPCtracker.cxx:7658
 AliTPCtracker.cxx:7659
 AliTPCtracker.cxx:7660
 AliTPCtracker.cxx:7661
 AliTPCtracker.cxx:7662
 AliTPCtracker.cxx:7663
 AliTPCtracker.cxx:7664
 AliTPCtracker.cxx:7665
 AliTPCtracker.cxx:7666
 AliTPCtracker.cxx:7667
 AliTPCtracker.cxx:7668
 AliTPCtracker.cxx:7669
 AliTPCtracker.cxx:7670
 AliTPCtracker.cxx:7671
 AliTPCtracker.cxx:7672
 AliTPCtracker.cxx:7673
 AliTPCtracker.cxx:7674
 AliTPCtracker.cxx:7675
 AliTPCtracker.cxx:7676
 AliTPCtracker.cxx:7677
 AliTPCtracker.cxx:7678
 AliTPCtracker.cxx:7679
 AliTPCtracker.cxx:7680
 AliTPCtracker.cxx:7681
 AliTPCtracker.cxx:7682
 AliTPCtracker.cxx:7683
 AliTPCtracker.cxx:7684
 AliTPCtracker.cxx:7685
 AliTPCtracker.cxx:7686
 AliTPCtracker.cxx:7687
 AliTPCtracker.cxx:7688
 AliTPCtracker.cxx:7689
 AliTPCtracker.cxx:7690
 AliTPCtracker.cxx:7691
 AliTPCtracker.cxx:7692
 AliTPCtracker.cxx:7693
 AliTPCtracker.cxx:7694
 AliTPCtracker.cxx:7695
 AliTPCtracker.cxx:7696
 AliTPCtracker.cxx:7697
 AliTPCtracker.cxx:7698
 AliTPCtracker.cxx:7699
 AliTPCtracker.cxx:7700
 AliTPCtracker.cxx:7701
 AliTPCtracker.cxx:7702
 AliTPCtracker.cxx:7703
 AliTPCtracker.cxx:7704
 AliTPCtracker.cxx:7705
 AliTPCtracker.cxx:7706
 AliTPCtracker.cxx:7707
 AliTPCtracker.cxx:7708
 AliTPCtracker.cxx:7709
 AliTPCtracker.cxx:7710
 AliTPCtracker.cxx:7711
 AliTPCtracker.cxx:7712
 AliTPCtracker.cxx:7713
 AliTPCtracker.cxx:7714
 AliTPCtracker.cxx:7715
 AliTPCtracker.cxx:7716
 AliTPCtracker.cxx:7717
 AliTPCtracker.cxx:7718
 AliTPCtracker.cxx:7719
 AliTPCtracker.cxx:7720
 AliTPCtracker.cxx:7721
 AliTPCtracker.cxx:7722
 AliTPCtracker.cxx:7723
 AliTPCtracker.cxx:7724
 AliTPCtracker.cxx:7725
 AliTPCtracker.cxx:7726
 AliTPCtracker.cxx:7727
 AliTPCtracker.cxx:7728
 AliTPCtracker.cxx:7729
 AliTPCtracker.cxx:7730
 AliTPCtracker.cxx:7731
 AliTPCtracker.cxx:7732
 AliTPCtracker.cxx:7733
 AliTPCtracker.cxx:7734
 AliTPCtracker.cxx:7735
 AliTPCtracker.cxx:7736
 AliTPCtracker.cxx:7737
 AliTPCtracker.cxx:7738
 AliTPCtracker.cxx:7739
 AliTPCtracker.cxx:7740
 AliTPCtracker.cxx:7741
 AliTPCtracker.cxx:7742
 AliTPCtracker.cxx:7743
 AliTPCtracker.cxx:7744
 AliTPCtracker.cxx:7745
 AliTPCtracker.cxx:7746
 AliTPCtracker.cxx:7747
 AliTPCtracker.cxx:7748
 AliTPCtracker.cxx:7749
 AliTPCtracker.cxx:7750
 AliTPCtracker.cxx:7751
 AliTPCtracker.cxx:7752
 AliTPCtracker.cxx:7753
 AliTPCtracker.cxx:7754
 AliTPCtracker.cxx:7755
 AliTPCtracker.cxx:7756
 AliTPCtracker.cxx:7757
 AliTPCtracker.cxx:7758
 AliTPCtracker.cxx:7759
 AliTPCtracker.cxx:7760
 AliTPCtracker.cxx:7761
 AliTPCtracker.cxx:7762
 AliTPCtracker.cxx:7763
 AliTPCtracker.cxx:7764
 AliTPCtracker.cxx:7765
 AliTPCtracker.cxx:7766
 AliTPCtracker.cxx:7767
 AliTPCtracker.cxx:7768
 AliTPCtracker.cxx:7769
 AliTPCtracker.cxx:7770
 AliTPCtracker.cxx:7771
 AliTPCtracker.cxx:7772
 AliTPCtracker.cxx:7773
 AliTPCtracker.cxx:7774
 AliTPCtracker.cxx:7775
 AliTPCtracker.cxx:7776
 AliTPCtracker.cxx:7777
 AliTPCtracker.cxx:7778
 AliTPCtracker.cxx:7779
 AliTPCtracker.cxx:7780
 AliTPCtracker.cxx:7781
 AliTPCtracker.cxx:7782
 AliTPCtracker.cxx:7783
 AliTPCtracker.cxx:7784
 AliTPCtracker.cxx:7785
 AliTPCtracker.cxx:7786
 AliTPCtracker.cxx:7787
 AliTPCtracker.cxx:7788
 AliTPCtracker.cxx:7789
 AliTPCtracker.cxx:7790
 AliTPCtracker.cxx:7791
 AliTPCtracker.cxx:7792
 AliTPCtracker.cxx:7793
 AliTPCtracker.cxx:7794
 AliTPCtracker.cxx:7795
 AliTPCtracker.cxx:7796
 AliTPCtracker.cxx:7797
 AliTPCtracker.cxx:7798
 AliTPCtracker.cxx:7799
 AliTPCtracker.cxx:7800
 AliTPCtracker.cxx:7801
 AliTPCtracker.cxx:7802
 AliTPCtracker.cxx:7803
 AliTPCtracker.cxx:7804
 AliTPCtracker.cxx:7805
 AliTPCtracker.cxx:7806
 AliTPCtracker.cxx:7807
 AliTPCtracker.cxx:7808
 AliTPCtracker.cxx:7809
 AliTPCtracker.cxx:7810
 AliTPCtracker.cxx:7811
 AliTPCtracker.cxx:7812
 AliTPCtracker.cxx:7813
 AliTPCtracker.cxx:7814
 AliTPCtracker.cxx:7815
 AliTPCtracker.cxx:7816
 AliTPCtracker.cxx:7817
 AliTPCtracker.cxx:7818
 AliTPCtracker.cxx:7819
 AliTPCtracker.cxx:7820
 AliTPCtracker.cxx:7821
 AliTPCtracker.cxx:7822
 AliTPCtracker.cxx:7823
 AliTPCtracker.cxx:7824
 AliTPCtracker.cxx:7825
 AliTPCtracker.cxx:7826
 AliTPCtracker.cxx:7827
 AliTPCtracker.cxx:7828
 AliTPCtracker.cxx:7829
 AliTPCtracker.cxx:7830
 AliTPCtracker.cxx:7831
 AliTPCtracker.cxx:7832
 AliTPCtracker.cxx:7833
 AliTPCtracker.cxx:7834
 AliTPCtracker.cxx:7835
 AliTPCtracker.cxx:7836
 AliTPCtracker.cxx:7837
 AliTPCtracker.cxx:7838
 AliTPCtracker.cxx:7839
 AliTPCtracker.cxx:7840
 AliTPCtracker.cxx:7841
 AliTPCtracker.cxx:7842
 AliTPCtracker.cxx:7843
 AliTPCtracker.cxx:7844
 AliTPCtracker.cxx:7845
 AliTPCtracker.cxx:7846
 AliTPCtracker.cxx:7847
 AliTPCtracker.cxx:7848
 AliTPCtracker.cxx:7849
 AliTPCtracker.cxx:7850
 AliTPCtracker.cxx:7851
 AliTPCtracker.cxx:7852
 AliTPCtracker.cxx:7853
 AliTPCtracker.cxx:7854
 AliTPCtracker.cxx:7855
 AliTPCtracker.cxx:7856
 AliTPCtracker.cxx:7857
 AliTPCtracker.cxx:7858
 AliTPCtracker.cxx:7859
 AliTPCtracker.cxx:7860
 AliTPCtracker.cxx:7861
 AliTPCtracker.cxx:7862
 AliTPCtracker.cxx:7863
 AliTPCtracker.cxx:7864
 AliTPCtracker.cxx:7865
 AliTPCtracker.cxx:7866
 AliTPCtracker.cxx:7867
 AliTPCtracker.cxx:7868
 AliTPCtracker.cxx:7869
 AliTPCtracker.cxx:7870
 AliTPCtracker.cxx:7871
 AliTPCtracker.cxx:7872
 AliTPCtracker.cxx:7873
 AliTPCtracker.cxx:7874
 AliTPCtracker.cxx:7875
 AliTPCtracker.cxx:7876
 AliTPCtracker.cxx:7877
 AliTPCtracker.cxx:7878
 AliTPCtracker.cxx:7879
 AliTPCtracker.cxx:7880
 AliTPCtracker.cxx:7881
 AliTPCtracker.cxx:7882
 AliTPCtracker.cxx:7883
 AliTPCtracker.cxx:7884
 AliTPCtracker.cxx:7885
 AliTPCtracker.cxx:7886
 AliTPCtracker.cxx:7887
 AliTPCtracker.cxx:7888
 AliTPCtracker.cxx:7889
 AliTPCtracker.cxx:7890
 AliTPCtracker.cxx:7891
 AliTPCtracker.cxx:7892
 AliTPCtracker.cxx:7893
 AliTPCtracker.cxx:7894
 AliTPCtracker.cxx:7895
 AliTPCtracker.cxx:7896
 AliTPCtracker.cxx:7897
 AliTPCtracker.cxx:7898
 AliTPCtracker.cxx:7899
 AliTPCtracker.cxx:7900
 AliTPCtracker.cxx:7901
 AliTPCtracker.cxx:7902
 AliTPCtracker.cxx:7903
 AliTPCtracker.cxx:7904
 AliTPCtracker.cxx:7905
 AliTPCtracker.cxx:7906
 AliTPCtracker.cxx:7907
 AliTPCtracker.cxx:7908
 AliTPCtracker.cxx:7909
 AliTPCtracker.cxx:7910
 AliTPCtracker.cxx:7911
 AliTPCtracker.cxx:7912
 AliTPCtracker.cxx:7913
 AliTPCtracker.cxx:7914
 AliTPCtracker.cxx:7915
 AliTPCtracker.cxx:7916
 AliTPCtracker.cxx:7917
 AliTPCtracker.cxx:7918
 AliTPCtracker.cxx:7919
 AliTPCtracker.cxx:7920
 AliTPCtracker.cxx:7921
 AliTPCtracker.cxx:7922
 AliTPCtracker.cxx:7923
 AliTPCtracker.cxx:7924
 AliTPCtracker.cxx:7925
 AliTPCtracker.cxx:7926
 AliTPCtracker.cxx:7927
 AliTPCtracker.cxx:7928
 AliTPCtracker.cxx:7929
 AliTPCtracker.cxx:7930
 AliTPCtracker.cxx:7931
 AliTPCtracker.cxx:7932
 AliTPCtracker.cxx:7933
 AliTPCtracker.cxx:7934
 AliTPCtracker.cxx:7935
 AliTPCtracker.cxx:7936
 AliTPCtracker.cxx:7937
 AliTPCtracker.cxx:7938
 AliTPCtracker.cxx:7939
 AliTPCtracker.cxx:7940
 AliTPCtracker.cxx:7941
 AliTPCtracker.cxx:7942
 AliTPCtracker.cxx:7943
 AliTPCtracker.cxx:7944
 AliTPCtracker.cxx:7945
 AliTPCtracker.cxx:7946
 AliTPCtracker.cxx:7947
 AliTPCtracker.cxx:7948
 AliTPCtracker.cxx:7949
 AliTPCtracker.cxx:7950
 AliTPCtracker.cxx:7951
 AliTPCtracker.cxx:7952
 AliTPCtracker.cxx:7953
 AliTPCtracker.cxx:7954
 AliTPCtracker.cxx:7955
 AliTPCtracker.cxx:7956
 AliTPCtracker.cxx:7957
 AliTPCtracker.cxx:7958
 AliTPCtracker.cxx:7959
 AliTPCtracker.cxx:7960
 AliTPCtracker.cxx:7961
 AliTPCtracker.cxx:7962
 AliTPCtracker.cxx:7963
 AliTPCtracker.cxx:7964
 AliTPCtracker.cxx:7965
 AliTPCtracker.cxx:7966
 AliTPCtracker.cxx:7967
 AliTPCtracker.cxx:7968
 AliTPCtracker.cxx:7969
 AliTPCtracker.cxx:7970
 AliTPCtracker.cxx:7971
 AliTPCtracker.cxx:7972
 AliTPCtracker.cxx:7973
 AliTPCtracker.cxx:7974
 AliTPCtracker.cxx:7975
 AliTPCtracker.cxx:7976
 AliTPCtracker.cxx:7977
 AliTPCtracker.cxx:7978
 AliTPCtracker.cxx:7979
 AliTPCtracker.cxx:7980
 AliTPCtracker.cxx:7981
 AliTPCtracker.cxx:7982
 AliTPCtracker.cxx:7983
 AliTPCtracker.cxx:7984
 AliTPCtracker.cxx:7985
 AliTPCtracker.cxx:7986
 AliTPCtracker.cxx:7987
 AliTPCtracker.cxx:7988
 AliTPCtracker.cxx:7989
 AliTPCtracker.cxx:7990
 AliTPCtracker.cxx:7991
 AliTPCtracker.cxx:7992
 AliTPCtracker.cxx:7993
 AliTPCtracker.cxx:7994
 AliTPCtracker.cxx:7995
 AliTPCtracker.cxx:7996
 AliTPCtracker.cxx:7997
 AliTPCtracker.cxx:7998
 AliTPCtracker.cxx:7999
 AliTPCtracker.cxx:8000
 AliTPCtracker.cxx:8001
 AliTPCtracker.cxx:8002
 AliTPCtracker.cxx:8003
 AliTPCtracker.cxx:8004
 AliTPCtracker.cxx:8005
 AliTPCtracker.cxx:8006
 AliTPCtracker.cxx:8007
 AliTPCtracker.cxx:8008
 AliTPCtracker.cxx:8009
 AliTPCtracker.cxx:8010
 AliTPCtracker.cxx:8011
 AliTPCtracker.cxx:8012
 AliTPCtracker.cxx:8013
 AliTPCtracker.cxx:8014
 AliTPCtracker.cxx:8015
 AliTPCtracker.cxx:8016
 AliTPCtracker.cxx:8017
 AliTPCtracker.cxx:8018
 AliTPCtracker.cxx:8019
 AliTPCtracker.cxx:8020
 AliTPCtracker.cxx:8021
 AliTPCtracker.cxx:8022
 AliTPCtracker.cxx:8023
 AliTPCtracker.cxx:8024
 AliTPCtracker.cxx:8025
 AliTPCtracker.cxx:8026
 AliTPCtracker.cxx:8027
 AliTPCtracker.cxx:8028
 AliTPCtracker.cxx:8029
 AliTPCtracker.cxx:8030
 AliTPCtracker.cxx:8031
 AliTPCtracker.cxx:8032
 AliTPCtracker.cxx:8033
 AliTPCtracker.cxx:8034
 AliTPCtracker.cxx:8035
 AliTPCtracker.cxx:8036
 AliTPCtracker.cxx:8037
 AliTPCtracker.cxx:8038
 AliTPCtracker.cxx:8039
 AliTPCtracker.cxx:8040
 AliTPCtracker.cxx:8041
 AliTPCtracker.cxx:8042
 AliTPCtracker.cxx:8043
 AliTPCtracker.cxx:8044
 AliTPCtracker.cxx:8045
 AliTPCtracker.cxx:8046
 AliTPCtracker.cxx:8047
 AliTPCtracker.cxx:8048
 AliTPCtracker.cxx:8049
 AliTPCtracker.cxx:8050
 AliTPCtracker.cxx:8051
 AliTPCtracker.cxx:8052
 AliTPCtracker.cxx:8053
 AliTPCtracker.cxx:8054
 AliTPCtracker.cxx:8055
 AliTPCtracker.cxx:8056
 AliTPCtracker.cxx:8057
 AliTPCtracker.cxx:8058
 AliTPCtracker.cxx:8059
 AliTPCtracker.cxx:8060
 AliTPCtracker.cxx:8061
 AliTPCtracker.cxx:8062
 AliTPCtracker.cxx:8063
 AliTPCtracker.cxx:8064
 AliTPCtracker.cxx:8065
 AliTPCtracker.cxx:8066
 AliTPCtracker.cxx:8067
 AliTPCtracker.cxx:8068
 AliTPCtracker.cxx:8069
 AliTPCtracker.cxx:8070
 AliTPCtracker.cxx:8071
 AliTPCtracker.cxx:8072
 AliTPCtracker.cxx:8073
 AliTPCtracker.cxx:8074
 AliTPCtracker.cxx:8075
 AliTPCtracker.cxx:8076
 AliTPCtracker.cxx:8077
 AliTPCtracker.cxx:8078
 AliTPCtracker.cxx:8079
 AliTPCtracker.cxx:8080
 AliTPCtracker.cxx:8081
 AliTPCtracker.cxx:8082
 AliTPCtracker.cxx:8083
 AliTPCtracker.cxx:8084
 AliTPCtracker.cxx:8085
 AliTPCtracker.cxx:8086
 AliTPCtracker.cxx:8087
 AliTPCtracker.cxx:8088
 AliTPCtracker.cxx:8089
 AliTPCtracker.cxx:8090
 AliTPCtracker.cxx:8091
 AliTPCtracker.cxx:8092
 AliTPCtracker.cxx:8093
 AliTPCtracker.cxx:8094
 AliTPCtracker.cxx:8095
 AliTPCtracker.cxx:8096
 AliTPCtracker.cxx:8097
 AliTPCtracker.cxx:8098
 AliTPCtracker.cxx:8099
 AliTPCtracker.cxx:8100
 AliTPCtracker.cxx:8101
 AliTPCtracker.cxx:8102
 AliTPCtracker.cxx:8103
 AliTPCtracker.cxx:8104
 AliTPCtracker.cxx:8105
 AliTPCtracker.cxx:8106
 AliTPCtracker.cxx:8107
 AliTPCtracker.cxx:8108
 AliTPCtracker.cxx:8109
 AliTPCtracker.cxx:8110
 AliTPCtracker.cxx:8111
 AliTPCtracker.cxx:8112
 AliTPCtracker.cxx:8113
 AliTPCtracker.cxx:8114
 AliTPCtracker.cxx:8115
 AliTPCtracker.cxx:8116
 AliTPCtracker.cxx:8117
 AliTPCtracker.cxx:8118
 AliTPCtracker.cxx:8119
 AliTPCtracker.cxx:8120
 AliTPCtracker.cxx:8121
 AliTPCtracker.cxx:8122
 AliTPCtracker.cxx:8123
 AliTPCtracker.cxx:8124
 AliTPCtracker.cxx:8125
 AliTPCtracker.cxx:8126
 AliTPCtracker.cxx:8127
 AliTPCtracker.cxx:8128
 AliTPCtracker.cxx:8129
 AliTPCtracker.cxx:8130
 AliTPCtracker.cxx:8131
 AliTPCtracker.cxx:8132
 AliTPCtracker.cxx:8133
 AliTPCtracker.cxx:8134
 AliTPCtracker.cxx:8135
 AliTPCtracker.cxx:8136
 AliTPCtracker.cxx:8137
 AliTPCtracker.cxx:8138
 AliTPCtracker.cxx:8139
 AliTPCtracker.cxx:8140
 AliTPCtracker.cxx:8141
 AliTPCtracker.cxx:8142
 AliTPCtracker.cxx:8143
 AliTPCtracker.cxx:8144
 AliTPCtracker.cxx:8145
 AliTPCtracker.cxx:8146
 AliTPCtracker.cxx:8147
 AliTPCtracker.cxx:8148
 AliTPCtracker.cxx:8149
 AliTPCtracker.cxx:8150
 AliTPCtracker.cxx:8151
 AliTPCtracker.cxx:8152
 AliTPCtracker.cxx:8153
 AliTPCtracker.cxx:8154
 AliTPCtracker.cxx:8155
 AliTPCtracker.cxx:8156
 AliTPCtracker.cxx:8157
 AliTPCtracker.cxx:8158
 AliTPCtracker.cxx:8159
 AliTPCtracker.cxx:8160
 AliTPCtracker.cxx:8161
 AliTPCtracker.cxx:8162
 AliTPCtracker.cxx:8163
 AliTPCtracker.cxx:8164
 AliTPCtracker.cxx:8165
 AliTPCtracker.cxx:8166
 AliTPCtracker.cxx:8167
 AliTPCtracker.cxx:8168
 AliTPCtracker.cxx:8169
 AliTPCtracker.cxx:8170
 AliTPCtracker.cxx:8171
 AliTPCtracker.cxx:8172
 AliTPCtracker.cxx:8173
 AliTPCtracker.cxx:8174
 AliTPCtracker.cxx:8175
 AliTPCtracker.cxx:8176
 AliTPCtracker.cxx:8177
 AliTPCtracker.cxx:8178
 AliTPCtracker.cxx:8179
 AliTPCtracker.cxx:8180
 AliTPCtracker.cxx:8181
 AliTPCtracker.cxx:8182
 AliTPCtracker.cxx:8183
 AliTPCtracker.cxx:8184
 AliTPCtracker.cxx:8185
 AliTPCtracker.cxx:8186
 AliTPCtracker.cxx:8187
 AliTPCtracker.cxx:8188
 AliTPCtracker.cxx:8189
 AliTPCtracker.cxx:8190
 AliTPCtracker.cxx:8191
 AliTPCtracker.cxx:8192
 AliTPCtracker.cxx:8193
 AliTPCtracker.cxx:8194
 AliTPCtracker.cxx:8195
 AliTPCtracker.cxx:8196
 AliTPCtracker.cxx:8197
 AliTPCtracker.cxx:8198
 AliTPCtracker.cxx:8199
 AliTPCtracker.cxx:8200
 AliTPCtracker.cxx:8201
 AliTPCtracker.cxx:8202
 AliTPCtracker.cxx:8203
 AliTPCtracker.cxx:8204
 AliTPCtracker.cxx:8205
 AliTPCtracker.cxx:8206
 AliTPCtracker.cxx:8207
 AliTPCtracker.cxx:8208
 AliTPCtracker.cxx:8209
 AliTPCtracker.cxx:8210
 AliTPCtracker.cxx:8211
 AliTPCtracker.cxx:8212
 AliTPCtracker.cxx:8213
 AliTPCtracker.cxx:8214
 AliTPCtracker.cxx:8215
 AliTPCtracker.cxx:8216
 AliTPCtracker.cxx:8217
 AliTPCtracker.cxx:8218
 AliTPCtracker.cxx:8219
 AliTPCtracker.cxx:8220
 AliTPCtracker.cxx:8221
 AliTPCtracker.cxx:8222
 AliTPCtracker.cxx:8223
 AliTPCtracker.cxx:8224
 AliTPCtracker.cxx:8225
 AliTPCtracker.cxx:8226
 AliTPCtracker.cxx:8227
 AliTPCtracker.cxx:8228
 AliTPCtracker.cxx:8229
 AliTPCtracker.cxx:8230
 AliTPCtracker.cxx:8231
 AliTPCtracker.cxx:8232
 AliTPCtracker.cxx:8233
 AliTPCtracker.cxx:8234
 AliTPCtracker.cxx:8235
 AliTPCtracker.cxx:8236
 AliTPCtracker.cxx:8237
 AliTPCtracker.cxx:8238
 AliTPCtracker.cxx:8239
 AliTPCtracker.cxx:8240
 AliTPCtracker.cxx:8241
 AliTPCtracker.cxx:8242
 AliTPCtracker.cxx:8243
 AliTPCtracker.cxx:8244
 AliTPCtracker.cxx:8245
 AliTPCtracker.cxx:8246
 AliTPCtracker.cxx:8247
 AliTPCtracker.cxx:8248
 AliTPCtracker.cxx:8249
 AliTPCtracker.cxx:8250
 AliTPCtracker.cxx:8251
 AliTPCtracker.cxx:8252
 AliTPCtracker.cxx:8253
 AliTPCtracker.cxx:8254
 AliTPCtracker.cxx:8255
 AliTPCtracker.cxx:8256
 AliTPCtracker.cxx:8257
 AliTPCtracker.cxx:8258
 AliTPCtracker.cxx:8259
 AliTPCtracker.cxx:8260
 AliTPCtracker.cxx:8261
 AliTPCtracker.cxx:8262
 AliTPCtracker.cxx:8263
 AliTPCtracker.cxx:8264
 AliTPCtracker.cxx:8265
 AliTPCtracker.cxx:8266
 AliTPCtracker.cxx:8267
 AliTPCtracker.cxx:8268
 AliTPCtracker.cxx:8269
 AliTPCtracker.cxx:8270
 AliTPCtracker.cxx:8271
 AliTPCtracker.cxx:8272
 AliTPCtracker.cxx:8273
 AliTPCtracker.cxx:8274
 AliTPCtracker.cxx:8275
 AliTPCtracker.cxx:8276
 AliTPCtracker.cxx:8277
 AliTPCtracker.cxx:8278
 AliTPCtracker.cxx:8279
 AliTPCtracker.cxx:8280
 AliTPCtracker.cxx:8281
 AliTPCtracker.cxx:8282
 AliTPCtracker.cxx:8283
 AliTPCtracker.cxx:8284
 AliTPCtracker.cxx:8285
 AliTPCtracker.cxx:8286
 AliTPCtracker.cxx:8287
 AliTPCtracker.cxx:8288
 AliTPCtracker.cxx:8289
 AliTPCtracker.cxx:8290
 AliTPCtracker.cxx:8291
 AliTPCtracker.cxx:8292
 AliTPCtracker.cxx:8293
 AliTPCtracker.cxx:8294
 AliTPCtracker.cxx:8295
 AliTPCtracker.cxx:8296
 AliTPCtracker.cxx:8297
 AliTPCtracker.cxx:8298
 AliTPCtracker.cxx:8299
 AliTPCtracker.cxx:8300
 AliTPCtracker.cxx:8301
 AliTPCtracker.cxx:8302
 AliTPCtracker.cxx:8303
 AliTPCtracker.cxx:8304
 AliTPCtracker.cxx:8305
 AliTPCtracker.cxx:8306
 AliTPCtracker.cxx:8307
 AliTPCtracker.cxx:8308
 AliTPCtracker.cxx:8309
 AliTPCtracker.cxx:8310
 AliTPCtracker.cxx:8311
 AliTPCtracker.cxx:8312
 AliTPCtracker.cxx:8313
 AliTPCtracker.cxx:8314
 AliTPCtracker.cxx:8315
 AliTPCtracker.cxx:8316
 AliTPCtracker.cxx:8317
 AliTPCtracker.cxx:8318
 AliTPCtracker.cxx:8319
 AliTPCtracker.cxx:8320
 AliTPCtracker.cxx:8321
 AliTPCtracker.cxx:8322
 AliTPCtracker.cxx:8323
 AliTPCtracker.cxx:8324
 AliTPCtracker.cxx:8325
 AliTPCtracker.cxx:8326
 AliTPCtracker.cxx:8327
 AliTPCtracker.cxx:8328
 AliTPCtracker.cxx:8329
 AliTPCtracker.cxx:8330
 AliTPCtracker.cxx:8331
 AliTPCtracker.cxx:8332
 AliTPCtracker.cxx:8333
 AliTPCtracker.cxx:8334
 AliTPCtracker.cxx:8335
 AliTPCtracker.cxx:8336
 AliTPCtracker.cxx:8337
 AliTPCtracker.cxx:8338
 AliTPCtracker.cxx:8339
 AliTPCtracker.cxx:8340
 AliTPCtracker.cxx:8341
 AliTPCtracker.cxx:8342
 AliTPCtracker.cxx:8343
 AliTPCtracker.cxx:8344
 AliTPCtracker.cxx:8345
 AliTPCtracker.cxx:8346
 AliTPCtracker.cxx:8347
 AliTPCtracker.cxx:8348
 AliTPCtracker.cxx:8349
 AliTPCtracker.cxx:8350
 AliTPCtracker.cxx:8351
 AliTPCtracker.cxx:8352
 AliTPCtracker.cxx:8353
 AliTPCtracker.cxx:8354
 AliTPCtracker.cxx:8355
 AliTPCtracker.cxx:8356
 AliTPCtracker.cxx:8357
 AliTPCtracker.cxx:8358
 AliTPCtracker.cxx:8359
 AliTPCtracker.cxx:8360
 AliTPCtracker.cxx:8361
 AliTPCtracker.cxx:8362
 AliTPCtracker.cxx:8363
 AliTPCtracker.cxx:8364
 AliTPCtracker.cxx:8365
 AliTPCtracker.cxx:8366
 AliTPCtracker.cxx:8367
 AliTPCtracker.cxx:8368
 AliTPCtracker.cxx:8369
 AliTPCtracker.cxx:8370
 AliTPCtracker.cxx:8371
 AliTPCtracker.cxx:8372
 AliTPCtracker.cxx:8373
 AliTPCtracker.cxx:8374
 AliTPCtracker.cxx:8375
 AliTPCtracker.cxx:8376
 AliTPCtracker.cxx:8377
 AliTPCtracker.cxx:8378
 AliTPCtracker.cxx:8379
 AliTPCtracker.cxx:8380
 AliTPCtracker.cxx:8381
 AliTPCtracker.cxx:8382
 AliTPCtracker.cxx:8383
 AliTPCtracker.cxx:8384
 AliTPCtracker.cxx:8385
 AliTPCtracker.cxx:8386
 AliTPCtracker.cxx:8387
 AliTPCtracker.cxx:8388
 AliTPCtracker.cxx:8389
 AliTPCtracker.cxx:8390
 AliTPCtracker.cxx:8391
 AliTPCtracker.cxx:8392
 AliTPCtracker.cxx:8393
 AliTPCtracker.cxx:8394
 AliTPCtracker.cxx:8395
 AliTPCtracker.cxx:8396
 AliTPCtracker.cxx:8397
 AliTPCtracker.cxx:8398
 AliTPCtracker.cxx:8399
 AliTPCtracker.cxx:8400
 AliTPCtracker.cxx:8401
 AliTPCtracker.cxx:8402
 AliTPCtracker.cxx:8403
 AliTPCtracker.cxx:8404
 AliTPCtracker.cxx:8405
 AliTPCtracker.cxx:8406
 AliTPCtracker.cxx:8407
 AliTPCtracker.cxx:8408
 AliTPCtracker.cxx:8409
 AliTPCtracker.cxx:8410
 AliTPCtracker.cxx:8411
 AliTPCtracker.cxx:8412
 AliTPCtracker.cxx:8413
 AliTPCtracker.cxx:8414
 AliTPCtracker.cxx:8415
 AliTPCtracker.cxx:8416
 AliTPCtracker.cxx:8417
 AliTPCtracker.cxx:8418
 AliTPCtracker.cxx:8419
 AliTPCtracker.cxx:8420
 AliTPCtracker.cxx:8421
 AliTPCtracker.cxx:8422
 AliTPCtracker.cxx:8423
 AliTPCtracker.cxx:8424
 AliTPCtracker.cxx:8425
 AliTPCtracker.cxx:8426
 AliTPCtracker.cxx:8427
 AliTPCtracker.cxx:8428
 AliTPCtracker.cxx:8429
 AliTPCtracker.cxx:8430
 AliTPCtracker.cxx:8431
 AliTPCtracker.cxx:8432
 AliTPCtracker.cxx:8433
 AliTPCtracker.cxx:8434
 AliTPCtracker.cxx:8435
 AliTPCtracker.cxx:8436
 AliTPCtracker.cxx:8437
 AliTPCtracker.cxx:8438
 AliTPCtracker.cxx:8439
 AliTPCtracker.cxx:8440
 AliTPCtracker.cxx:8441
 AliTPCtracker.cxx:8442
 AliTPCtracker.cxx:8443
 AliTPCtracker.cxx:8444
 AliTPCtracker.cxx:8445
 AliTPCtracker.cxx:8446
 AliTPCtracker.cxx:8447
 AliTPCtracker.cxx:8448
 AliTPCtracker.cxx:8449
 AliTPCtracker.cxx:8450
 AliTPCtracker.cxx:8451
 AliTPCtracker.cxx:8452
 AliTPCtracker.cxx:8453
 AliTPCtracker.cxx:8454
 AliTPCtracker.cxx:8455
 AliTPCtracker.cxx:8456
 AliTPCtracker.cxx:8457
 AliTPCtracker.cxx:8458
 AliTPCtracker.cxx:8459
 AliTPCtracker.cxx:8460
 AliTPCtracker.cxx:8461
 AliTPCtracker.cxx:8462
 AliTPCtracker.cxx:8463
 AliTPCtracker.cxx:8464
 AliTPCtracker.cxx:8465
 AliTPCtracker.cxx:8466
 AliTPCtracker.cxx:8467
 AliTPCtracker.cxx:8468
 AliTPCtracker.cxx:8469
 AliTPCtracker.cxx:8470
 AliTPCtracker.cxx:8471
 AliTPCtracker.cxx:8472
 AliTPCtracker.cxx:8473
 AliTPCtracker.cxx:8474
 AliTPCtracker.cxx:8475
 AliTPCtracker.cxx:8476
 AliTPCtracker.cxx:8477
 AliTPCtracker.cxx:8478
 AliTPCtracker.cxx:8479
 AliTPCtracker.cxx:8480
 AliTPCtracker.cxx:8481
 AliTPCtracker.cxx:8482
 AliTPCtracker.cxx:8483
 AliTPCtracker.cxx:8484
 AliTPCtracker.cxx:8485
 AliTPCtracker.cxx:8486
 AliTPCtracker.cxx:8487
 AliTPCtracker.cxx:8488
 AliTPCtracker.cxx:8489
 AliTPCtracker.cxx:8490
 AliTPCtracker.cxx:8491
 AliTPCtracker.cxx:8492
 AliTPCtracker.cxx:8493
 AliTPCtracker.cxx:8494
 AliTPCtracker.cxx:8495
 AliTPCtracker.cxx:8496
 AliTPCtracker.cxx:8497
 AliTPCtracker.cxx:8498
 AliTPCtracker.cxx:8499
 AliTPCtracker.cxx:8500
 AliTPCtracker.cxx:8501
 AliTPCtracker.cxx:8502
 AliTPCtracker.cxx:8503
 AliTPCtracker.cxx:8504
 AliTPCtracker.cxx:8505
 AliTPCtracker.cxx:8506
 AliTPCtracker.cxx:8507
 AliTPCtracker.cxx:8508
 AliTPCtracker.cxx:8509
 AliTPCtracker.cxx:8510
 AliTPCtracker.cxx:8511
 AliTPCtracker.cxx:8512
 AliTPCtracker.cxx:8513
 AliTPCtracker.cxx:8514
 AliTPCtracker.cxx:8515
 AliTPCtracker.cxx:8516
 AliTPCtracker.cxx:8517
 AliTPCtracker.cxx:8518
 AliTPCtracker.cxx:8519
 AliTPCtracker.cxx:8520
 AliTPCtracker.cxx:8521
 AliTPCtracker.cxx:8522
 AliTPCtracker.cxx:8523
 AliTPCtracker.cxx:8524
 AliTPCtracker.cxx:8525
 AliTPCtracker.cxx:8526
 AliTPCtracker.cxx:8527
 AliTPCtracker.cxx:8528
 AliTPCtracker.cxx:8529
 AliTPCtracker.cxx:8530
 AliTPCtracker.cxx:8531
 AliTPCtracker.cxx:8532
 AliTPCtracker.cxx:8533
 AliTPCtracker.cxx:8534
 AliTPCtracker.cxx:8535
 AliTPCtracker.cxx:8536
 AliTPCtracker.cxx:8537
 AliTPCtracker.cxx:8538
 AliTPCtracker.cxx:8539
 AliTPCtracker.cxx:8540
 AliTPCtracker.cxx:8541
 AliTPCtracker.cxx:8542
 AliTPCtracker.cxx:8543
 AliTPCtracker.cxx:8544
 AliTPCtracker.cxx:8545
 AliTPCtracker.cxx:8546
 AliTPCtracker.cxx:8547
 AliTPCtracker.cxx:8548
 AliTPCtracker.cxx:8549
 AliTPCtracker.cxx:8550
 AliTPCtracker.cxx:8551
 AliTPCtracker.cxx:8552
 AliTPCtracker.cxx:8553
 AliTPCtracker.cxx:8554
 AliTPCtracker.cxx:8555
 AliTPCtracker.cxx:8556
 AliTPCtracker.cxx:8557
 AliTPCtracker.cxx:8558
 AliTPCtracker.cxx:8559
 AliTPCtracker.cxx:8560
 AliTPCtracker.cxx:8561
 AliTPCtracker.cxx:8562
 AliTPCtracker.cxx:8563
 AliTPCtracker.cxx:8564
 AliTPCtracker.cxx:8565
 AliTPCtracker.cxx:8566
 AliTPCtracker.cxx:8567
 AliTPCtracker.cxx:8568
 AliTPCtracker.cxx:8569
 AliTPCtracker.cxx:8570
 AliTPCtracker.cxx:8571
 AliTPCtracker.cxx:8572
 AliTPCtracker.cxx:8573
 AliTPCtracker.cxx:8574
 AliTPCtracker.cxx:8575
 AliTPCtracker.cxx:8576
 AliTPCtracker.cxx:8577
 AliTPCtracker.cxx:8578
 AliTPCtracker.cxx:8579
 AliTPCtracker.cxx:8580
 AliTPCtracker.cxx:8581
 AliTPCtracker.cxx:8582
 AliTPCtracker.cxx:8583
 AliTPCtracker.cxx:8584
 AliTPCtracker.cxx:8585
 AliTPCtracker.cxx:8586
 AliTPCtracker.cxx:8587
 AliTPCtracker.cxx:8588
 AliTPCtracker.cxx:8589
 AliTPCtracker.cxx:8590
 AliTPCtracker.cxx:8591
 AliTPCtracker.cxx:8592
 AliTPCtracker.cxx:8593
 AliTPCtracker.cxx:8594
 AliTPCtracker.cxx:8595
 AliTPCtracker.cxx:8596
 AliTPCtracker.cxx:8597
 AliTPCtracker.cxx:8598
 AliTPCtracker.cxx:8599
 AliTPCtracker.cxx:8600
 AliTPCtracker.cxx:8601
 AliTPCtracker.cxx:8602
 AliTPCtracker.cxx:8603
 AliTPCtracker.cxx:8604
 AliTPCtracker.cxx:8605
 AliTPCtracker.cxx:8606
 AliTPCtracker.cxx:8607
 AliTPCtracker.cxx:8608
 AliTPCtracker.cxx:8609
 AliTPCtracker.cxx:8610
 AliTPCtracker.cxx:8611
 AliTPCtracker.cxx:8612
 AliTPCtracker.cxx:8613
 AliTPCtracker.cxx:8614
 AliTPCtracker.cxx:8615
 AliTPCtracker.cxx:8616
 AliTPCtracker.cxx:8617
 AliTPCtracker.cxx:8618
 AliTPCtracker.cxx:8619
 AliTPCtracker.cxx:8620
 AliTPCtracker.cxx:8621
 AliTPCtracker.cxx:8622
 AliTPCtracker.cxx:8623
 AliTPCtracker.cxx:8624
 AliTPCtracker.cxx:8625
 AliTPCtracker.cxx:8626
 AliTPCtracker.cxx:8627
 AliTPCtracker.cxx:8628
 AliTPCtracker.cxx:8629
 AliTPCtracker.cxx:8630
 AliTPCtracker.cxx:8631
 AliTPCtracker.cxx:8632
 AliTPCtracker.cxx:8633
 AliTPCtracker.cxx:8634
 AliTPCtracker.cxx:8635
 AliTPCtracker.cxx:8636
 AliTPCtracker.cxx:8637
 AliTPCtracker.cxx:8638
 AliTPCtracker.cxx:8639
 AliTPCtracker.cxx:8640
 AliTPCtracker.cxx:8641
 AliTPCtracker.cxx:8642
 AliTPCtracker.cxx:8643
 AliTPCtracker.cxx:8644
 AliTPCtracker.cxx:8645
 AliTPCtracker.cxx:8646
 AliTPCtracker.cxx:8647
 AliTPCtracker.cxx:8648
 AliTPCtracker.cxx:8649
 AliTPCtracker.cxx:8650
 AliTPCtracker.cxx:8651
 AliTPCtracker.cxx:8652
 AliTPCtracker.cxx:8653
 AliTPCtracker.cxx:8654
 AliTPCtracker.cxx:8655
 AliTPCtracker.cxx:8656
 AliTPCtracker.cxx:8657
 AliTPCtracker.cxx:8658
 AliTPCtracker.cxx:8659
 AliTPCtracker.cxx:8660
 AliTPCtracker.cxx:8661
 AliTPCtracker.cxx:8662
 AliTPCtracker.cxx:8663
 AliTPCtracker.cxx:8664
 AliTPCtracker.cxx:8665
 AliTPCtracker.cxx:8666
 AliTPCtracker.cxx:8667
 AliTPCtracker.cxx:8668
 AliTPCtracker.cxx:8669
 AliTPCtracker.cxx:8670
 AliTPCtracker.cxx:8671
 AliTPCtracker.cxx:8672
 AliTPCtracker.cxx:8673
 AliTPCtracker.cxx:8674
 AliTPCtracker.cxx:8675
 AliTPCtracker.cxx:8676
 AliTPCtracker.cxx:8677
 AliTPCtracker.cxx:8678
 AliTPCtracker.cxx:8679
 AliTPCtracker.cxx:8680
 AliTPCtracker.cxx:8681
 AliTPCtracker.cxx:8682
 AliTPCtracker.cxx:8683
 AliTPCtracker.cxx:8684
 AliTPCtracker.cxx:8685
 AliTPCtracker.cxx:8686
 AliTPCtracker.cxx:8687
 AliTPCtracker.cxx:8688
 AliTPCtracker.cxx:8689
 AliTPCtracker.cxx:8690
 AliTPCtracker.cxx:8691
 AliTPCtracker.cxx:8692
 AliTPCtracker.cxx:8693
 AliTPCtracker.cxx:8694
 AliTPCtracker.cxx:8695
 AliTPCtracker.cxx:8696
 AliTPCtracker.cxx:8697
 AliTPCtracker.cxx:8698
 AliTPCtracker.cxx:8699
 AliTPCtracker.cxx:8700
 AliTPCtracker.cxx:8701
 AliTPCtracker.cxx:8702
 AliTPCtracker.cxx:8703
 AliTPCtracker.cxx:8704
 AliTPCtracker.cxx:8705
 AliTPCtracker.cxx:8706
 AliTPCtracker.cxx:8707
 AliTPCtracker.cxx:8708
 AliTPCtracker.cxx:8709
 AliTPCtracker.cxx:8710
 AliTPCtracker.cxx:8711
 AliTPCtracker.cxx:8712
 AliTPCtracker.cxx:8713
 AliTPCtracker.cxx:8714
 AliTPCtracker.cxx:8715
 AliTPCtracker.cxx:8716
 AliTPCtracker.cxx:8717
 AliTPCtracker.cxx:8718
 AliTPCtracker.cxx:8719
 AliTPCtracker.cxx:8720
 AliTPCtracker.cxx:8721
 AliTPCtracker.cxx:8722
 AliTPCtracker.cxx:8723
 AliTPCtracker.cxx:8724
 AliTPCtracker.cxx:8725
 AliTPCtracker.cxx:8726
 AliTPCtracker.cxx:8727
 AliTPCtracker.cxx:8728
 AliTPCtracker.cxx:8729
 AliTPCtracker.cxx:8730
 AliTPCtracker.cxx:8731
 AliTPCtracker.cxx:8732
 AliTPCtracker.cxx:8733
 AliTPCtracker.cxx:8734
 AliTPCtracker.cxx:8735
 AliTPCtracker.cxx:8736
 AliTPCtracker.cxx:8737
 AliTPCtracker.cxx:8738
 AliTPCtracker.cxx:8739
 AliTPCtracker.cxx:8740
 AliTPCtracker.cxx:8741
 AliTPCtracker.cxx:8742
 AliTPCtracker.cxx:8743
 AliTPCtracker.cxx:8744
 AliTPCtracker.cxx:8745
 AliTPCtracker.cxx:8746
 AliTPCtracker.cxx:8747
 AliTPCtracker.cxx:8748
 AliTPCtracker.cxx:8749
 AliTPCtracker.cxx:8750
 AliTPCtracker.cxx:8751
 AliTPCtracker.cxx:8752
 AliTPCtracker.cxx:8753
 AliTPCtracker.cxx:8754
 AliTPCtracker.cxx:8755
 AliTPCtracker.cxx:8756
 AliTPCtracker.cxx:8757
 AliTPCtracker.cxx:8758
 AliTPCtracker.cxx:8759
 AliTPCtracker.cxx:8760
 AliTPCtracker.cxx:8761
 AliTPCtracker.cxx:8762
 AliTPCtracker.cxx:8763
 AliTPCtracker.cxx:8764
 AliTPCtracker.cxx:8765
 AliTPCtracker.cxx:8766
 AliTPCtracker.cxx:8767
 AliTPCtracker.cxx:8768
 AliTPCtracker.cxx:8769
 AliTPCtracker.cxx:8770
 AliTPCtracker.cxx:8771
 AliTPCtracker.cxx:8772
 AliTPCtracker.cxx:8773
 AliTPCtracker.cxx:8774
 AliTPCtracker.cxx:8775
 AliTPCtracker.cxx:8776
 AliTPCtracker.cxx:8777
 AliTPCtracker.cxx:8778
 AliTPCtracker.cxx:8779
 AliTPCtracker.cxx:8780
 AliTPCtracker.cxx:8781
 AliTPCtracker.cxx:8782
 AliTPCtracker.cxx:8783
 AliTPCtracker.cxx:8784
 AliTPCtracker.cxx:8785
 AliTPCtracker.cxx:8786
 AliTPCtracker.cxx:8787
 AliTPCtracker.cxx:8788
 AliTPCtracker.cxx:8789
 AliTPCtracker.cxx:8790
 AliTPCtracker.cxx:8791
 AliTPCtracker.cxx:8792
 AliTPCtracker.cxx:8793
 AliTPCtracker.cxx:8794
 AliTPCtracker.cxx:8795
 AliTPCtracker.cxx:8796
 AliTPCtracker.cxx:8797
 AliTPCtracker.cxx:8798
 AliTPCtracker.cxx:8799
 AliTPCtracker.cxx:8800
 AliTPCtracker.cxx:8801
 AliTPCtracker.cxx:8802
 AliTPCtracker.cxx:8803
 AliTPCtracker.cxx:8804
 AliTPCtracker.cxx:8805
 AliTPCtracker.cxx:8806
 AliTPCtracker.cxx:8807
 AliTPCtracker.cxx:8808
 AliTPCtracker.cxx:8809
 AliTPCtracker.cxx:8810
 AliTPCtracker.cxx:8811
 AliTPCtracker.cxx:8812
 AliTPCtracker.cxx:8813
 AliTPCtracker.cxx:8814
 AliTPCtracker.cxx:8815
 AliTPCtracker.cxx:8816
 AliTPCtracker.cxx:8817
 AliTPCtracker.cxx:8818
 AliTPCtracker.cxx:8819
 AliTPCtracker.cxx:8820
 AliTPCtracker.cxx:8821
 AliTPCtracker.cxx:8822
 AliTPCtracker.cxx:8823
 AliTPCtracker.cxx:8824
 AliTPCtracker.cxx:8825
 AliTPCtracker.cxx:8826
 AliTPCtracker.cxx:8827
 AliTPCtracker.cxx:8828
 AliTPCtracker.cxx:8829
 AliTPCtracker.cxx:8830
 AliTPCtracker.cxx:8831
 AliTPCtracker.cxx:8832
 AliTPCtracker.cxx:8833
 AliTPCtracker.cxx:8834
 AliTPCtracker.cxx:8835
 AliTPCtracker.cxx:8836
 AliTPCtracker.cxx:8837
 AliTPCtracker.cxx:8838
 AliTPCtracker.cxx:8839
 AliTPCtracker.cxx:8840
 AliTPCtracker.cxx:8841
 AliTPCtracker.cxx:8842
 AliTPCtracker.cxx:8843
 AliTPCtracker.cxx:8844
 AliTPCtracker.cxx:8845
 AliTPCtracker.cxx:8846
 AliTPCtracker.cxx:8847
 AliTPCtracker.cxx:8848
 AliTPCtracker.cxx:8849
 AliTPCtracker.cxx:8850
 AliTPCtracker.cxx:8851
 AliTPCtracker.cxx:8852
 AliTPCtracker.cxx:8853
 AliTPCtracker.cxx:8854
 AliTPCtracker.cxx:8855
 AliTPCtracker.cxx:8856
 AliTPCtracker.cxx:8857
 AliTPCtracker.cxx:8858
 AliTPCtracker.cxx:8859
 AliTPCtracker.cxx:8860
 AliTPCtracker.cxx:8861
 AliTPCtracker.cxx:8862
 AliTPCtracker.cxx:8863
 AliTPCtracker.cxx:8864
 AliTPCtracker.cxx:8865
 AliTPCtracker.cxx:8866
 AliTPCtracker.cxx:8867
 AliTPCtracker.cxx:8868
 AliTPCtracker.cxx:8869
 AliTPCtracker.cxx:8870
 AliTPCtracker.cxx:8871
 AliTPCtracker.cxx:8872
 AliTPCtracker.cxx:8873
 AliTPCtracker.cxx:8874
 AliTPCtracker.cxx:8875
 AliTPCtracker.cxx:8876
 AliTPCtracker.cxx:8877
 AliTPCtracker.cxx:8878
 AliTPCtracker.cxx:8879
 AliTPCtracker.cxx:8880
 AliTPCtracker.cxx:8881
 AliTPCtracker.cxx:8882
 AliTPCtracker.cxx:8883
 AliTPCtracker.cxx:8884
 AliTPCtracker.cxx:8885
 AliTPCtracker.cxx:8886
 AliTPCtracker.cxx:8887
 AliTPCtracker.cxx:8888
 AliTPCtracker.cxx:8889
 AliTPCtracker.cxx:8890
 AliTPCtracker.cxx:8891
 AliTPCtracker.cxx:8892
 AliTPCtracker.cxx:8893
 AliTPCtracker.cxx:8894
 AliTPCtracker.cxx:8895
 AliTPCtracker.cxx:8896
 AliTPCtracker.cxx:8897
 AliTPCtracker.cxx:8898
 AliTPCtracker.cxx:8899
 AliTPCtracker.cxx:8900
 AliTPCtracker.cxx:8901
 AliTPCtracker.cxx:8902
 AliTPCtracker.cxx:8903
 AliTPCtracker.cxx:8904
 AliTPCtracker.cxx:8905
 AliTPCtracker.cxx:8906
 AliTPCtracker.cxx:8907
 AliTPCtracker.cxx:8908
 AliTPCtracker.cxx:8909
 AliTPCtracker.cxx:8910
 AliTPCtracker.cxx:8911
 AliTPCtracker.cxx:8912
 AliTPCtracker.cxx:8913
 AliTPCtracker.cxx:8914
 AliTPCtracker.cxx:8915
 AliTPCtracker.cxx:8916
 AliTPCtracker.cxx:8917
 AliTPCtracker.cxx:8918
 AliTPCtracker.cxx:8919
 AliTPCtracker.cxx:8920
 AliTPCtracker.cxx:8921
 AliTPCtracker.cxx:8922
 AliTPCtracker.cxx:8923
 AliTPCtracker.cxx:8924
 AliTPCtracker.cxx:8925
 AliTPCtracker.cxx:8926
 AliTPCtracker.cxx:8927
 AliTPCtracker.cxx:8928
 AliTPCtracker.cxx:8929
 AliTPCtracker.cxx:8930
 AliTPCtracker.cxx:8931
 AliTPCtracker.cxx:8932
 AliTPCtracker.cxx:8933
 AliTPCtracker.cxx:8934
 AliTPCtracker.cxx:8935
 AliTPCtracker.cxx:8936
 AliTPCtracker.cxx:8937
 AliTPCtracker.cxx:8938
 AliTPCtracker.cxx:8939
 AliTPCtracker.cxx:8940
 AliTPCtracker.cxx:8941
 AliTPCtracker.cxx:8942
 AliTPCtracker.cxx:8943
 AliTPCtracker.cxx:8944
 AliTPCtracker.cxx:8945
 AliTPCtracker.cxx:8946
 AliTPCtracker.cxx:8947
 AliTPCtracker.cxx:8948
 AliTPCtracker.cxx:8949
 AliTPCtracker.cxx:8950
 AliTPCtracker.cxx:8951
 AliTPCtracker.cxx:8952
 AliTPCtracker.cxx:8953
 AliTPCtracker.cxx:8954
 AliTPCtracker.cxx:8955
 AliTPCtracker.cxx:8956
 AliTPCtracker.cxx:8957
 AliTPCtracker.cxx:8958
 AliTPCtracker.cxx:8959
 AliTPCtracker.cxx:8960
 AliTPCtracker.cxx:8961
 AliTPCtracker.cxx:8962
 AliTPCtracker.cxx:8963
 AliTPCtracker.cxx:8964
 AliTPCtracker.cxx:8965
 AliTPCtracker.cxx:8966
 AliTPCtracker.cxx:8967
 AliTPCtracker.cxx:8968
 AliTPCtracker.cxx:8969
 AliTPCtracker.cxx:8970
 AliTPCtracker.cxx:8971
 AliTPCtracker.cxx:8972
 AliTPCtracker.cxx:8973
 AliTPCtracker.cxx:8974
 AliTPCtracker.cxx:8975
 AliTPCtracker.cxx:8976
 AliTPCtracker.cxx:8977
 AliTPCtracker.cxx:8978
 AliTPCtracker.cxx:8979
 AliTPCtracker.cxx:8980
 AliTPCtracker.cxx:8981
 AliTPCtracker.cxx:8982
 AliTPCtracker.cxx:8983
 AliTPCtracker.cxx:8984
 AliTPCtracker.cxx:8985
 AliTPCtracker.cxx:8986
 AliTPCtracker.cxx:8987
 AliTPCtracker.cxx:8988
 AliTPCtracker.cxx:8989
 AliTPCtracker.cxx:8990
 AliTPCtracker.cxx:8991
 AliTPCtracker.cxx:8992
 AliTPCtracker.cxx:8993
 AliTPCtracker.cxx:8994
 AliTPCtracker.cxx:8995
 AliTPCtracker.cxx:8996
 AliTPCtracker.cxx:8997
 AliTPCtracker.cxx:8998
 AliTPCtracker.cxx:8999
 AliTPCtracker.cxx:9000
 AliTPCtracker.cxx:9001
 AliTPCtracker.cxx:9002
 AliTPCtracker.cxx:9003
 AliTPCtracker.cxx:9004
 AliTPCtracker.cxx:9005
 AliTPCtracker.cxx:9006
 AliTPCtracker.cxx:9007
 AliTPCtracker.cxx:9008
 AliTPCtracker.cxx:9009
 AliTPCtracker.cxx:9010
 AliTPCtracker.cxx:9011
 AliTPCtracker.cxx:9012
 AliTPCtracker.cxx:9013
 AliTPCtracker.cxx:9014