ROOT logo
/**************************************************************************
 * Copyright(c) 1998-2007, 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.                  *
 **************************************************************************/

/* $Id$ */

//----------------------------------------------------------------------------
//    Implementation of the heavy-flavour vertexing analysis class
// Candidates are stored in the AOD as objects deriving from AliAODRecoDecay.
// To be used as a task of AliAnalysisManager by means of the interface
// class AliAnalysisTaskSEVertexingHF. 
// An example of usage in the macro AliAnalysisTaskSEVertexingHFTest.C.
//
//  Contact: andrea.dainese@pd.infn.it
//  Contributors: E.Bruna, G.E.Bruno, A.Dainese, C.Di Gliglio,
//                F.Prino, R.Romita, X.M.Zhang
//----------------------------------------------------------------------------
#include <Riostream.h>
#include <TFile.h>
#include <TDatabasePDG.h>
#include <TString.h>
#include <TList.h>
#include "AliLog.h"
#include "AliVEvent.h"
#include "AliVVertex.h"
#include "AliVTrack.h"
#include "AliVertexerTracks.h"
#include "AliKFVertex.h"
#include "AliESDEvent.h"
#include "AliESDVertex.h"
#include "AliExternalTrackParam.h"
#include "AliNeutralTrackParam.h"
#include "AliESDtrack.h"
#include "AliESDtrackCuts.h"
#include "AliAODEvent.h"
#include "AliPIDResponse.h"
#include "AliAODRecoDecay.h"
#include "AliAODRecoDecayHF.h"
#include "AliAODRecoDecayHF2Prong.h"
#include "AliAODRecoDecayHF3Prong.h"
#include "AliAODRecoDecayHF4Prong.h"
#include "AliAODRecoCascadeHF.h"
#include "AliRDHFCutsD0toKpi.h"
#include "AliRDHFCutsJpsitoee.h"
#include "AliRDHFCutsDplustoKpipi.h"
#include "AliRDHFCutsDstoKKpi.h"
#include "AliRDHFCutsLctopKpi.h"
#include "AliRDHFCutsLctoV0.h"
#include "AliRDHFCutsD0toKpipipi.h"
#include "AliRDHFCutsDStartoKpipi.h"
#include "AliAnalysisFilter.h"
#include "AliAnalysisVertexingHF.h"
#include "AliMixedEvent.h"
#include "AliESDv0.h"
#include "AliAODv0.h"
#include "AliCodeTimer.h"
#include <cstring>

ClassImp(AliAnalysisVertexingHF)

//----------------------------------------------------------------------------
AliAnalysisVertexingHF::AliAnalysisVertexingHF():
fInputAOD(kFALSE),
fAODMapSize(0),
fAODMap(0),
fVertexerTracks(0x0),
fBzkG(0.),
fSecVtxWithKF(kFALSE),
fRecoPrimVtxSkippingTrks(kFALSE),
fRmTrksFromPrimVtx(kFALSE),
fV1(0x0),
fD0toKpi(kTRUE),
fJPSItoEle(kTRUE),
f3Prong(kTRUE),
f4Prong(kTRUE),
fDstar(kTRUE),
fCascades(kTRUE),
fLikeSign(kFALSE),
fLikeSign3prong(kFALSE),
fMixEvent(kFALSE),
fPidResponse(0x0),
fUseKaonPIDfor3Prong(kFALSE),
fUsePIDforLc(0),
fUsePIDforLc2V0(0),
fUseKaonPIDforDs(kFALSE),
fUseTPCPID(kFALSE),
fUseTOFPID(kFALSE),
fUseTPCPIDOnlyIfNoTOF(kFALSE),
fMaxMomForTPCPid(1.),
fnSigmaTPCPionLow(5.),
fnSigmaTPCPionHi(5.),
fnSigmaTOFPionLow(5.),
fnSigmaTOFPionHi(5.),
fnSigmaTPCKaonLow(5.),
fnSigmaTPCKaonHi(5.),
fnSigmaTOFKaonLow(5.),
fnSigmaTOFKaonHi(5.),
fnSigmaTPCProtonLow(5.),
fnSigmaTPCProtonHi(5.),
fnSigmaTOFProtonLow(5.),
fnSigmaTOFProtonHi(5.),
fMaxCentPercentileForTightCuts(-9999),
fTrackFilter(0x0),
fTrackFilter2prongCentral(0x0),
fTrackFilter3prongCentral(0x0),
fTrackFilterSoftPi(0x0),
fCutsD0toKpi(0x0),
fCutsJpsitoee(0x0),
fCutsDplustoKpipi(0x0),
fCutsDstoKKpi(0x0),
fCutsLctopKpi(0x0),
fCutsLctoV0(0x0),
fCutsD0toKpipipi(0x0),
fCutsDStartoKpipi(0x0),
fListOfCuts(0x0),
fFindVertexForDstar(kTRUE),
fFindVertexForCascades(kTRUE),
fV0TypeForCascadeVertex(0),
fMassCutBeforeVertexing(kFALSE),
fMassCalc2(0),
fMassCalc3(0),
fMassCalc4(0),
fOKInvMassD0(kFALSE),
fOKInvMassJpsi(kFALSE),
fOKInvMassDplus(kFALSE),
fOKInvMassDs(kFALSE),
fOKInvMassLc(kFALSE),
fOKInvMassDstar(kFALSE),
fOKInvMassD0to4p(kFALSE),
fOKInvMassLctoV0(kFALSE),
fnTrksTotal(0),
fnSeleTrksTotal(0),
fMassDzero(0.),
fMassDplus(0.),
fMassDs(0.),
fMassLambdaC(0.),
fMassDstar(0.),
fMassJpsi(0.)
{
  // Default constructor

  Double_t d02[2]={0.,0.};
  Double_t d03[3]={0.,0.,0.};
  Double_t d04[4]={0.,0.,0.,0.};
  fMassCalc2 = new AliAODRecoDecay(0x0,2,0,d02);
  fMassCalc3 = new AliAODRecoDecay(0x0,3,1,d03);
  fMassCalc4 = new AliAODRecoDecay(0x0,4,0,d04);
  SetMasses();
}
//--------------------------------------------------------------------------
AliAnalysisVertexingHF::AliAnalysisVertexingHF(const AliAnalysisVertexingHF &source) : 
TNamed(source),
fInputAOD(source.fInputAOD),
fAODMapSize(source.fAODMapSize),
fAODMap(source.fAODMap),
fVertexerTracks(source.fVertexerTracks),
fBzkG(source.fBzkG),
fSecVtxWithKF(source.fSecVtxWithKF),
fRecoPrimVtxSkippingTrks(source.fRecoPrimVtxSkippingTrks),
fRmTrksFromPrimVtx(source.fRmTrksFromPrimVtx),
fV1(source.fV1),
fD0toKpi(source.fD0toKpi),
fJPSItoEle(source.fJPSItoEle),
f3Prong(source.f3Prong),
f4Prong(source.f4Prong),
fDstar(source.fDstar),
fCascades(source.fCascades),
fLikeSign(source.fLikeSign),
fLikeSign3prong(source.fLikeSign3prong),
fMixEvent(source.fMixEvent),
fPidResponse(source.fPidResponse),
fUseKaonPIDfor3Prong(source.fUseKaonPIDfor3Prong),
fUsePIDforLc(source.fUsePIDforLc),
fUsePIDforLc2V0(source.fUsePIDforLc2V0),
fUseKaonPIDforDs(source.fUseKaonPIDforDs),
fUseTPCPID(source.fUseTPCPID),
fUseTOFPID(source.fUseTOFPID),
fUseTPCPIDOnlyIfNoTOF(source.fUseTPCPIDOnlyIfNoTOF),
fMaxMomForTPCPid(source.fMaxMomForTPCPid),
fnSigmaTPCPionLow(source.fnSigmaTPCPionLow),
fnSigmaTPCPionHi(source.fnSigmaTPCPionHi),
fnSigmaTOFPionLow(source.fnSigmaTOFPionLow),
fnSigmaTOFPionHi(source.fnSigmaTOFPionHi),
fnSigmaTPCKaonLow(source.fnSigmaTPCKaonLow),
fnSigmaTPCKaonHi(source.fnSigmaTPCKaonHi),
fnSigmaTOFKaonLow(source.fnSigmaTOFKaonLow),
fnSigmaTOFKaonHi(source.fnSigmaTOFKaonHi),
fnSigmaTPCProtonLow(source.fnSigmaTPCProtonLow),
fnSigmaTPCProtonHi(source.fnSigmaTPCProtonHi),
fnSigmaTOFProtonLow(source.fnSigmaTOFProtonLow),
fnSigmaTOFProtonHi(source.fnSigmaTOFProtonHi),
fMaxCentPercentileForTightCuts(source.fMaxCentPercentileForTightCuts),
fTrackFilter(source.fTrackFilter),
fTrackFilter2prongCentral(source.fTrackFilter2prongCentral),
fTrackFilter3prongCentral(source.fTrackFilter3prongCentral),
fTrackFilterSoftPi(source.fTrackFilterSoftPi),
fCutsD0toKpi(source.fCutsD0toKpi),
fCutsJpsitoee(source.fCutsJpsitoee),
fCutsDplustoKpipi(source.fCutsDplustoKpipi),
fCutsDstoKKpi(source.fCutsDstoKKpi),
fCutsLctopKpi(source.fCutsLctopKpi),
fCutsLctoV0(source.fCutsLctoV0),
fCutsD0toKpipipi(source.fCutsD0toKpipipi),
fCutsDStartoKpipi(source.fCutsDStartoKpipi),
fListOfCuts(source.fListOfCuts),
fFindVertexForDstar(source.fFindVertexForDstar),
fFindVertexForCascades(source.fFindVertexForCascades),
fV0TypeForCascadeVertex(source.fV0TypeForCascadeVertex),
fMassCutBeforeVertexing(source.fMassCutBeforeVertexing),
fMassCalc2(source.fMassCalc2),
fMassCalc3(source.fMassCalc3),
fMassCalc4(source.fMassCalc4),
fOKInvMassD0(source.fOKInvMassD0),
fOKInvMassJpsi(source.fOKInvMassJpsi),
fOKInvMassDplus(source.fOKInvMassDplus),
fOKInvMassDs(source.fOKInvMassDs),
fOKInvMassLc(source.fOKInvMassLc),
fOKInvMassDstar(source.fOKInvMassDstar),
fOKInvMassD0to4p(source.fOKInvMassD0to4p),
fOKInvMassLctoV0(source.fOKInvMassLctoV0),
fnTrksTotal(0),
fnSeleTrksTotal(0),
fMassDzero(source.fMassDzero),
fMassDplus(source.fMassDplus),
fMassDs(source.fMassDs),
fMassLambdaC(source.fMassLambdaC),
fMassDstar(source.fMassDstar),
fMassJpsi(source.fMassJpsi)
{
  //
  // Copy constructor
  //
}
//--------------------------------------------------------------------------
AliAnalysisVertexingHF &AliAnalysisVertexingHF::operator=(const AliAnalysisVertexingHF &source)
{
  //
  // assignment operator
  //
  if(&source == this) return *this;
  fInputAOD = source.fInputAOD;
  fAODMapSize = source.fAODMapSize;
  fVertexerTracks = source.fVertexerTracks;
  fBzkG = source.fBzkG;
  fSecVtxWithKF = source.fSecVtxWithKF;
  fRecoPrimVtxSkippingTrks = source.fRecoPrimVtxSkippingTrks;
  fRmTrksFromPrimVtx = source.fRmTrksFromPrimVtx;
  fV1 = source.fV1;
  fD0toKpi = source.fD0toKpi;
  fJPSItoEle = source.fJPSItoEle;
  f3Prong = source.f3Prong;
  f4Prong = source.f4Prong;
  fDstar = source.fDstar;
  fCascades = source.fCascades;
  fLikeSign = source.fLikeSign;
  fLikeSign3prong = source.fLikeSign3prong;
  fMixEvent = source.fMixEvent;
  fPidResponse = source.fPidResponse;
  fUseKaonPIDfor3Prong = source.fUseKaonPIDfor3Prong;
  fUsePIDforLc = source.fUsePIDforLc;
  fUsePIDforLc2V0 = source.fUsePIDforLc2V0;
  fUseKaonPIDforDs = source.fUseKaonPIDforDs;
  fUseTPCPID = source.fUseTPCPID;
  fUseTOFPID = source.fUseTOFPID;
  fUseTPCPIDOnlyIfNoTOF = source.fUseTPCPIDOnlyIfNoTOF;
  fMaxMomForTPCPid = source.fMaxMomForTPCPid;
  fnSigmaTPCPionLow = source.fnSigmaTPCPionLow;
  fnSigmaTPCPionHi = source.fnSigmaTPCPionHi;
  fnSigmaTOFPionLow = source.fnSigmaTOFPionLow;
  fnSigmaTOFPionHi = source.fnSigmaTOFPionHi;
  fnSigmaTPCKaonLow = source.fnSigmaTPCKaonLow;
  fnSigmaTPCKaonHi = source.fnSigmaTPCKaonHi;
  fnSigmaTOFKaonLow = source.fnSigmaTOFKaonLow;
  fnSigmaTOFKaonHi = source.fnSigmaTOFKaonHi;
  fnSigmaTPCProtonLow = source.fnSigmaTPCProtonLow;
  fnSigmaTPCProtonHi = source.fnSigmaTPCProtonHi;
  fnSigmaTOFProtonLow = source.fnSigmaTOFProtonLow;
  fnSigmaTOFProtonHi = source.fnSigmaTOFProtonHi;
  fnSigmaTOFKaonLow = source.fnSigmaTOFKaonLow;
  fnSigmaTOFKaonHi = source.fnSigmaTOFKaonHi;
  fMaxCentPercentileForTightCuts = source.fMaxCentPercentileForTightCuts;
  fTrackFilter = source.fTrackFilter;
  fTrackFilter2prongCentral = source.fTrackFilter2prongCentral;
  fTrackFilter3prongCentral = source.fTrackFilter3prongCentral;
  fTrackFilterSoftPi = source.fTrackFilterSoftPi;
  fCutsD0toKpi = source.fCutsD0toKpi;
  fCutsJpsitoee = source.fCutsJpsitoee;
  fCutsDplustoKpipi = source.fCutsDplustoKpipi;
  fCutsDstoKKpi = source.fCutsDstoKKpi;
  fCutsLctopKpi = source.fCutsLctopKpi;
  fCutsLctoV0 = source.fCutsLctoV0;
  fCutsD0toKpipipi = source.fCutsD0toKpipipi;
  fCutsDStartoKpipi = source.fCutsDStartoKpipi;
  fListOfCuts = source.fListOfCuts;
  fFindVertexForDstar = source.fFindVertexForDstar;
  fFindVertexForCascades = source.fFindVertexForCascades;
  fV0TypeForCascadeVertex = source.fV0TypeForCascadeVertex;
  fMassCutBeforeVertexing = source.fMassCutBeforeVertexing;
  fMassCalc2 = source.fMassCalc2;
  fMassCalc3 = source.fMassCalc3;
  fMassCalc4 = source.fMassCalc4;
  fOKInvMassD0 = source.fOKInvMassD0;
  fOKInvMassJpsi = source.fOKInvMassJpsi;
  fOKInvMassDplus = source.fOKInvMassDplus;
  fOKInvMassDs = source.fOKInvMassDs;
  fOKInvMassLc = source.fOKInvMassLc;
  fOKInvMassDstar = source.fOKInvMassDstar;
  fOKInvMassD0to4p = source.fOKInvMassD0to4p;
  fOKInvMassLctoV0 = source.fOKInvMassLctoV0;
  fMassDzero = source.fMassDzero;
  fMassDplus = source.fMassDplus;
  fMassDs = source.fMassDs;
  fMassLambdaC = source.fMassLambdaC;
  fMassDstar = source.fMassDstar;
  fMassJpsi = source.fMassJpsi;

  return *this;
}
//----------------------------------------------------------------------------
AliAnalysisVertexingHF::~AliAnalysisVertexingHF() {
  // Destructor
  if(fV1) { delete fV1; fV1=0; }
  delete fVertexerTracks;
  if(fTrackFilter) { delete fTrackFilter; fTrackFilter=0; }
  if(fTrackFilter2prongCentral) { delete fTrackFilter2prongCentral; fTrackFilter2prongCentral=0; }
  if(fTrackFilter3prongCentral) { delete fTrackFilter3prongCentral; fTrackFilter3prongCentral=0; }
  if(fTrackFilterSoftPi) { delete fTrackFilterSoftPi; fTrackFilterSoftPi=0; }
  if(fCutsD0toKpi) { delete fCutsD0toKpi; fCutsD0toKpi=0; }
  if(fCutsJpsitoee) { delete fCutsJpsitoee; fCutsJpsitoee=0; }
  if(fCutsDplustoKpipi) { delete fCutsDplustoKpipi; fCutsDplustoKpipi=0; }
  if(fCutsDstoKKpi) { delete fCutsDstoKKpi; fCutsDstoKKpi=0; }
  if(fCutsLctopKpi) { delete fCutsLctopKpi; fCutsLctopKpi=0; }
  if(fCutsLctoV0) { delete fCutsLctoV0; fCutsLctoV0=0; }
  if(fCutsD0toKpipipi) { delete fCutsD0toKpipipi; fCutsD0toKpipipi=0; }
  if(fCutsDStartoKpipi) { delete fCutsDStartoKpipi; fCutsDStartoKpipi=0; }
  if(fAODMap) { delete [] fAODMap; fAODMap=0; }
  if(fMassCalc2) { delete fMassCalc2; fMassCalc2=0; }
  if(fMassCalc3) { delete fMassCalc3; fMassCalc3=0; }
  if(fMassCalc4) { delete fMassCalc4; fMassCalc4=0; }
}
//----------------------------------------------------------------------------
TList *AliAnalysisVertexingHF::FillListOfCuts() {
  // Fill list of analysis cuts

  TList *list = new TList();
  list->SetOwner();
  list->SetName("ListOfCuts");
  
  if(fCutsD0toKpi) {
    AliRDHFCutsD0toKpi *cutsD0toKpi = new AliRDHFCutsD0toKpi(*fCutsD0toKpi);
    list->Add(cutsD0toKpi);
  }
  if(fCutsJpsitoee) {
    AliRDHFCutsJpsitoee *cutsJpsitoee = new AliRDHFCutsJpsitoee(*fCutsJpsitoee);
    list->Add(cutsJpsitoee);
  }
  if(fCutsDplustoKpipi) {
    AliRDHFCutsDplustoKpipi *cutsDplustoKpipi = new AliRDHFCutsDplustoKpipi(*fCutsDplustoKpipi);
    list->Add(cutsDplustoKpipi);
  }
  if(fCutsDstoKKpi) {
    AliRDHFCutsDstoKKpi *cutsDstoKKpi = new AliRDHFCutsDstoKKpi(*fCutsDstoKKpi);
    list->Add(cutsDstoKKpi);
  }
  if(fCutsLctopKpi) {
    AliRDHFCutsLctopKpi *cutsLctopKpi = new AliRDHFCutsLctopKpi(*fCutsLctopKpi);
    list->Add(cutsLctopKpi);
  }
  if(fCutsLctoV0){
    AliRDHFCutsLctoV0 *cutsLctoV0 = new AliRDHFCutsLctoV0(*fCutsLctoV0);
    list->Add(cutsLctoV0);
  }
  if(fCutsD0toKpipipi) {
    AliRDHFCutsD0toKpipipi *cutsD0toKpipipi = new AliRDHFCutsD0toKpipipi(*fCutsD0toKpipipi);
    list->Add(cutsD0toKpipipi);
  }
  if(fCutsDStartoKpipi) {
    AliRDHFCutsDStartoKpipi *cutsDStartoKpipi = new AliRDHFCutsDStartoKpipi(*fCutsDStartoKpipi);
    list->Add(cutsDStartoKpipi);
  }
  
  //___ Check consitstency of cuts between vertexer and analysis tasks
  Bool_t bCutsOk = CheckCutsConsistency();
  if (bCutsOk == kFALSE) {AliFatal("AliAnalysisVertexingHF::FillListOfCuts vertexing and the analysis task cuts are not consistent!");}

  // keep a pointer to the list
  fListOfCuts = list;

  return list;
}
//----------------------------------------------------------------------------
void AliAnalysisVertexingHF::FindCandidates(AliVEvent *event,
					    TClonesArray *aodVerticesHFTClArr,
					    TClonesArray *aodD0toKpiTClArr,
					    TClonesArray *aodJPSItoEleTClArr,
					    TClonesArray *aodCharm3ProngTClArr,
					    TClonesArray *aodCharm4ProngTClArr,
					    TClonesArray *aodDstarTClArr,
					    TClonesArray *aodCascadesTClArr,
					    TClonesArray *aodLikeSign2ProngTClArr,
					    TClonesArray *aodLikeSign3ProngTClArr)
{
  // Find heavy-flavour vertex candidates
  // Input:  ESD or AOD
  // Output: AOD (additional branches added)
  //AliCodeTimerAuto("",0);

  if(!fMixEvent){
    TString evtype = event->IsA()->GetName();
    fInputAOD = ((evtype=="AliAODEvent") ? kTRUE : kFALSE);
  } // if we do mixing AliVEvent is a AliMixedEvent

  if(fInputAOD) {
    AliDebug(2,"Creating HF candidates from AOD");
  } else {
    AliDebug(2,"Creating HF candidates from ESD");
  }

  if(!aodVerticesHFTClArr) {
    printf("ERROR: no aodVerticesHFTClArr");
    return;
  }
  if((fD0toKpi || fDstar) && !aodD0toKpiTClArr) {
    printf("ERROR: no aodD0toKpiTClArr");
    return;
  }
  if(fJPSItoEle && !aodJPSItoEleTClArr) {
    printf("ERROR: no aodJPSItoEleTClArr");
    return;
  }
  if(f3Prong && !aodCharm3ProngTClArr) {
    printf("ERROR: no aodCharm3ProngTClArr");
    return;
  }
  if(f4Prong && !aodCharm4ProngTClArr) {
    printf("ERROR: no aodCharm4ProngTClArr");
    return;
  }
  if(fDstar && !aodDstarTClArr) {
    printf("ERROR: no aodDstarTClArr");
    return;
  }
  if(fCascades && !aodCascadesTClArr){
    printf("ERROR: no aodCascadesTClArr ");
    return;
  }
  if(fLikeSign && !aodLikeSign2ProngTClArr) {
    printf("ERROR: no aodLikeSign2ProngTClArr");
    return;
  }
  if(fLikeSign3prong && f3Prong && !aodLikeSign3ProngTClArr) {
    printf("ERROR: no aodLikeSign3ProngTClArr");
    return;
  }

  // delete candidates from previous event and create references
  Int_t iVerticesHF=0,iD0toKpi=0,iJPSItoEle=0,i3Prong=0,i4Prong=0,iDstar=0,iCascades=0,iLikeSign2Prong=0,iLikeSign3Prong=0;
  aodVerticesHFTClArr->Delete();
  iVerticesHF = aodVerticesHFTClArr->GetEntriesFast();
  TClonesArray &verticesHFRef = *aodVerticesHFTClArr;
  if(fD0toKpi || fDstar)   {
    aodD0toKpiTClArr->Delete();
    iD0toKpi = aodD0toKpiTClArr->GetEntriesFast();
  }
  if(fJPSItoEle) {
    aodJPSItoEleTClArr->Delete();
    iJPSItoEle = aodJPSItoEleTClArr->GetEntriesFast();
  }
  if(f3Prong) {   
    aodCharm3ProngTClArr->Delete();
    i3Prong = aodCharm3ProngTClArr->GetEntriesFast();
  }
  if(f4Prong) {
    aodCharm4ProngTClArr->Delete();
    i4Prong = aodCharm4ProngTClArr->GetEntriesFast();
  }
  if(fDstar) {
    aodDstarTClArr->Delete();
    iDstar = aodDstarTClArr->GetEntriesFast();
  }
  if(fCascades) {
    aodCascadesTClArr->Delete();
    iCascades = aodCascadesTClArr->GetEntriesFast();
  }
  if(fLikeSign) {                                
    aodLikeSign2ProngTClArr->Delete();                     
    iLikeSign2Prong = aodLikeSign2ProngTClArr->GetEntriesFast(); 
  }  
  if(fLikeSign3prong && f3Prong) {                                
    aodLikeSign3ProngTClArr->Delete();                     
    iLikeSign3Prong = aodLikeSign3ProngTClArr->GetEntriesFast(); 
  }  

  TClonesArray &aodD0toKpiRef        = *aodD0toKpiTClArr;
  TClonesArray &aodJPSItoEleRef      = *aodJPSItoEleTClArr;
  TClonesArray &aodCharm3ProngRef    = *aodCharm3ProngTClArr;
  TClonesArray &aodCharm4ProngRef    = *aodCharm4ProngTClArr;
  TClonesArray &aodDstarRef          = *aodDstarTClArr;
  TClonesArray &aodCascadesRef       = *aodCascadesTClArr;
  TClonesArray &aodLikeSign2ProngRef = *aodLikeSign2ProngTClArr;
  TClonesArray &aodLikeSign3ProngRef = *aodLikeSign3ProngTClArr;


  AliAODRecoDecayHF2Prong *io2Prong  = 0;
  AliAODRecoDecayHF3Prong *io3Prong  = 0;
  AliAODRecoDecayHF4Prong *io4Prong  = 0;
  AliAODRecoCascadeHF     *ioCascade = 0;

  Int_t    iTrkP1,iTrkP2,iTrkN1,iTrkN2,iTrkSoftPi,trkEntries,iv0,nv0;
  Double_t xdummy,ydummy,dcap1n1,dcap1n2,dcap2n1,dcap1p2,dcan1n2,dcap2n2,dcaV0,dcaCasc;
  Bool_t   okD0=kFALSE,okJPSI=kFALSE,ok3Prong=kFALSE,ok4Prong=kFALSE;
  Bool_t   okDstar=kFALSE,okD0fromDstar=kFALSE;
  Bool_t   okCascades=kFALSE;
  AliESDtrack *postrack1 = 0;
  AliESDtrack *postrack2 = 0;
  AliESDtrack *negtrack1 = 0;
  AliESDtrack *negtrack2 = 0;
  AliESDtrack *trackPi   = 0;
  Double_t mompos1[3],mompos2[3],momneg1[3],momneg2[3];
  //   AliESDtrack *posV0track = 0;
  //   AliESDtrack *negV0track = 0;
  Float_t dcaMax = fCutsD0toKpi->GetDCACut();
  if(fCutsJpsitoee) dcaMax=TMath::Max(dcaMax,fCutsJpsitoee->GetDCACut());
  if(fCutsDplustoKpipi) dcaMax=TMath::Max(dcaMax,fCutsDplustoKpipi->GetDCACut());
  if(fCutsDstoKKpi) dcaMax=TMath::Max(dcaMax,fCutsDstoKKpi->GetDCACut());
  if(fCutsLctopKpi) dcaMax=TMath::Max(dcaMax,fCutsLctopKpi->GetDCACut());
  if(fCutsD0toKpipipi) dcaMax=TMath::Max(dcaMax,fCutsD0toKpipipi->GetDCACut());
  if(fCutsDStartoKpipi) dcaMax=TMath::Max(dcaMax,fCutsDStartoKpipi->GetDCACut());
  
  AliDebug(2,Form(" dca cut set to %f cm",dcaMax));


  // get Bz
  fBzkG = (Double_t)event->GetMagneticField(); 
  if(!fVertexerTracks){
    fVertexerTracks=new AliVertexerTracks(fBzkG);
  }else{
    Double_t oldField=fVertexerTracks->GetFieldkG();
    if(oldField!=fBzkG) fVertexerTracks->SetFieldkG(fBzkG);
  }

  trkEntries = (Int_t)event->GetNumberOfTracks();
  AliDebug(1,Form(" Number of tracks: %d",trkEntries));
  fnTrksTotal += trkEntries;

  nv0 = (Int_t)event->GetNumberOfV0s();
  AliDebug(1,Form(" Number of V0s: %d",nv0));

  if( trkEntries<2 && (trkEntries<1 || nv0<1) ) {
    AliDebug(1,Form(" Not enough tracks: %d",trkEntries));
    return;
  }

  // event selection + PID configuration
  if(!fCutsD0toKpi->IsEventSelected(event)) return;
  if(fCutsJpsitoee) fCutsJpsitoee->SetupPID(event);
  if(fCutsDplustoKpipi) fCutsDplustoKpipi->SetupPID(event);
  if(fCutsDstoKKpi) fCutsDstoKKpi->SetupPID(event);
  if(fCutsLctopKpi) fCutsLctopKpi->SetupPID(event);
  if(fCutsLctoV0) fCutsLctoV0->SetupPID(event);
  if(fCutsD0toKpipipi) fCutsD0toKpipipi->SetupPID(event);
  if(fCutsDStartoKpipi) fCutsDStartoKpipi->SetupPID(event);

  // call function that applies sigle-track selection,
  // for displaced tracks and soft pions (both charges) for D*,
  // and retrieves primary vertex
  TObjArray seleTrksArray(trkEntries);
  TObjArray tracksAtVertex(trkEntries);
  UChar_t  *seleFlags = new UChar_t[trkEntries]; // bit 0: displaced, bit 1: softpi, bit 2: 3 prong, bits 3-4-5: for PID
  Int_t     nSeleTrks=0;
  Int_t *evtNumber    = new Int_t[trkEntries];
  SelectTracksAndCopyVertex(event,trkEntries,seleTrksArray,tracksAtVertex,nSeleTrks,seleFlags,evtNumber);

  AliDebug(1,Form(" Selected tracks: %d",nSeleTrks));
  fnSeleTrksTotal += nSeleTrks;
    

  TObjArray *twoTrackArray1    = new TObjArray(2);
  TObjArray *twoTrackArray2    = new TObjArray(2);
  TObjArray *twoTrackArrayV0   = new TObjArray(2);
  TObjArray *twoTrackArrayCasc = new TObjArray(2);
  TObjArray *threeTrackArray   = new TObjArray(3);
  TObjArray *fourTrackArray    = new TObjArray(4);

  Double_t dispersion;
  Bool_t isLikeSign2Prong=kFALSE,isLikeSign3Prong=kFALSE;

  AliAODRecoDecayHF   *rd = 0;
  AliAODRecoCascadeHF *rc = 0;
  AliAODv0            *v0 = 0;
  AliESDv0         *esdV0 = 0;

  Bool_t massCutOK=kTRUE;

  // LOOP ON  POSITIVE  TRACKS
  for(iTrkP1=0; iTrkP1<nSeleTrks; iTrkP1++) {

    //if(iTrkP1%1==0) AliDebug(1,Form("  1st loop on pos: track number %d of %d",iTrkP1,nSeleTrks));  
    //if(iTrkP1%1==0) printf("  1st loop on pos: track number %d of %d\n",iTrkP1,nSeleTrks);  

    // get track from tracks array
    postrack1 = (AliESDtrack*)seleTrksArray.UncheckedAt(iTrkP1);
    if(!TESTBIT(seleFlags[iTrkP1],kBitDispl)) continue;
    postrack1->GetPxPyPz(mompos1);

    // Make cascades with V0+track
    // 
    if(fCascades) {
      // loop on V0's
      for(iv0=0; iv0<nv0; iv0++){

	//AliDebug(1,Form("   loop on v0s for track number %d and v0 number %d",iTrkP1,iv0));	

        if ( fUsePIDforLc2V0 && !TESTBIT(seleFlags[iTrkP1],kBitProtonCompat) ) continue; //clm

	// Get the V0 
	if(fInputAOD) {
	  v0 = ((AliAODEvent*)event)->GetV0(iv0);
	} else {
	  esdV0 = ((AliESDEvent*)event)->GetV0(iv0);
	}
	if ( (!v0 || !v0->IsA()->InheritsFrom("AliAODv0") ) && 
	     (!esdV0 || !esdV0->IsA()->InheritsFrom("AliESDv0") ) ) continue;
	
	if ( v0 && ((v0->GetOnFlyStatus() == kTRUE  && fV0TypeForCascadeVertex == AliRDHFCuts::kOnlyOfflineV0s) ||
                    (v0->GetOnFlyStatus() == kFALSE && fV0TypeForCascadeVertex == AliRDHFCuts::kOnlyOnTheFlyV0s)) ) continue;

        if ( esdV0 && ((esdV0->GetOnFlyStatus() == kTRUE  && fV0TypeForCascadeVertex == AliRDHFCuts::kOnlyOfflineV0s) ||
                      ( esdV0->GetOnFlyStatus() == kFALSE && fV0TypeForCascadeVertex == AliRDHFCuts::kOnlyOnTheFlyV0s)) ) continue;

	// Get the tracks that form the V0
	//  ( parameters at primary vertex )
	//   and define an AliExternalTrackParam out of them
	AliExternalTrackParam * posV0track;
	AliExternalTrackParam * negV0track;

	if(fInputAOD){
          AliAODTrack *posVV0track = (AliAODTrack*)(v0->GetDaughter(0));
	  AliAODTrack *negVV0track = (AliAODTrack*)(v0->GetDaughter(1));
	  if( !posVV0track || !negVV0track ) continue;
	  //
	  // Apply some basic V0 daughter criteria
	  //
	  // bachelor must not be a v0-track                                                                  
	  if (posVV0track->GetID() == postrack1->GetID() ||
	      negVV0track->GetID() == postrack1->GetID()) continue;
	  // reject like-sign v0                                                                              
	  if ( posVV0track->Charge() == negVV0track->Charge() ) continue;
	  // avoid ghost TPC tracks                                                                           
	  if(!(posVV0track->GetStatus() & AliESDtrack::kTPCrefit) ||
	     !(negVV0track->GetStatus() & AliESDtrack::kTPCrefit)) continue;
	  // Get AliExternalTrackParam out of the AliAODTracks
	  Double_t xyz[3], pxpypz[3], cv[21]; Short_t sign;
	  posVV0track->PxPyPz(pxpypz); 	                  posVV0track->XvYvZv(xyz);
	  posVV0track->GetCovarianceXYZPxPyPz(cv);	  sign=posVV0track->Charge();
	  posV0track = new AliExternalTrackParam(xyz,pxpypz,cv,sign);
	  negVV0track->PxPyPz(pxpypz); 	                  negVV0track->XvYvZv(xyz);
	  negVV0track->GetCovarianceXYZPxPyPz(cv);	  sign=negVV0track->Charge();
	  negV0track = new AliExternalTrackParam(xyz,pxpypz,cv,sign);
	}  else {
	  AliESDtrack *posVV0track = (AliESDtrack*)(event->GetTrack( esdV0->GetPindex() ));
          AliESDtrack *negVV0track = (AliESDtrack*)(event->GetTrack( esdV0->GetNindex() ));
	  if( !posVV0track || !negVV0track ) continue;
	  //
	  // Apply some basic V0 daughter criteria
	  //
	  // bachelor must not be a v0-track                                                                  
	  if (posVV0track->GetID() == postrack1->GetID() ||
	      negVV0track->GetID() == postrack1->GetID()) continue;
	  // reject like-sign v0                                                                              
	  if ( posVV0track->Charge() == negVV0track->Charge() ) continue;
	  // avoid ghost TPC tracks                                                                           
	  if(!(posVV0track->GetStatus() & AliESDtrack::kTPCrefit) ||
	     !(negVV0track->GetStatus() & AliESDtrack::kTPCrefit)) continue;
	  //  reject kinks (only necessary on AliESDtracks)
	  if (posVV0track->GetKinkIndex(0)>0  || negVV0track->GetKinkIndex(0)>0) continue;
	  // Get AliExternalTrackParam out of the AliESDtracks	
	  posV0track = new AliExternalTrackParam(*posVV0track);
	  negV0track = new AliExternalTrackParam(*negVV0track);

	  // Define the AODv0 from ESDv0 if reading ESDs
	  v0 = TransformESDv0toAODv0(esdV0,twoTrackArrayV0);
	}
	if( !posV0track || !negV0track ){
	  AliDebug(1,Form(" Couldn't get the V0 daughters"));
	  continue;
	}

	// fill in the v0 two-external-track-param array
 	twoTrackArrayV0->AddAt(posV0track,0);
 	twoTrackArrayV0->AddAt(negV0track,1);

 	// Get the V0 dca
	dcaV0 = v0->DcaV0Daughters();

	// Define the V0 (neutral) track
	AliNeutralTrackParam *trackV0=NULL;
	if(fInputAOD) {
	  const AliVTrack *trackVV0 = dynamic_cast<const AliVTrack*>(v0);
	  if(trackVV0)  trackV0 = new AliNeutralTrackParam(trackVV0);
	} else {  
	  Double_t xyz[3], pxpypz[3];
	  esdV0->XvYvZv(xyz);
	  esdV0->PxPyPz(pxpypz);
	  Double_t cv[21]; for(int i=0; i<21; i++) cv[i]=0;
	  trackV0 = new AliNeutralTrackParam(xyz,pxpypz,cv,0);
	}


	// Fill in the object array to create the cascade
	twoTrackArrayCasc->AddAt(postrack1,0);
	twoTrackArrayCasc->AddAt(trackV0,1);
	// Compute the cascade vertex
	AliAODVertex *vertexCasc = 0;
	if(fFindVertexForCascades) {  
	  // DCA between the two tracks
	  dcaCasc = postrack1->GetDCA(trackV0,fBzkG,xdummy,ydummy);
	  // Vertexing+	  
	  vertexCasc = ReconstructSecondaryVertex(twoTrackArrayCasc,dispersion,kFALSE);
	} else {
	  // assume Cascade decays at the primary vertex
	  Double_t pos[3],cov[6],chi2perNDF;
	  fV1->GetXYZ(pos);
	  fV1->GetCovMatrix(cov);
	  chi2perNDF = fV1->GetChi2toNDF();
	  vertexCasc = new AliAODVertex(pos,cov,chi2perNDF,0x0,-1,AliAODVertex::kUndef,2);
	  dcaCasc = 0.;
	}
	if(!vertexCasc) {
	  delete posV0track; posV0track=NULL;
	  delete negV0track; negV0track=NULL;
	  delete trackV0; trackV0=NULL;
	  if(!fInputAOD) {delete v0; v0=NULL;}
	  twoTrackArrayV0->Clear();
	  twoTrackArrayCasc->Clear();
	  continue; 
	}

	// Create and store the Cascade if passed the cuts
	ioCascade = MakeCascade(twoTrackArrayCasc,event,vertexCasc,v0,dcaCasc,okCascades);
	if(okCascades && ioCascade) {
	  //AliDebug(1,Form("Storing a cascade object... "));
	  // add the vertex and the cascade to the AOD
	  AliAODVertex *vCasc = new(verticesHFRef[iVerticesHF++])AliAODVertex(*vertexCasc);
	  rc = new(aodCascadesRef[iCascades++])AliAODRecoCascadeHF(*ioCascade);
	  rc->SetSecondaryVtx(vCasc);
	  vCasc->SetParent(rc);
	  rc->SetPrimaryVtxRef((AliAODVertex*)event->GetPrimaryVertex());
	  if(!fInputAOD) vCasc->AddDaughter(v0); // just to fill ref #0 ??
	  AddRefs(vCasc,rc,event,twoTrackArrayCasc); // add the track (proton)
	  vCasc->AddDaughter(v0); // fill the 2prong V0 
	}

	// Clean up 
	delete posV0track; posV0track=NULL;
	delete negV0track; negV0track=NULL;
	delete trackV0; trackV0=NULL;
	twoTrackArrayV0->Clear();
	twoTrackArrayCasc->Clear();
	if(ioCascade) { delete ioCascade; ioCascade=NULL; }
	if(vertexCasc) { delete vertexCasc; vertexCasc=NULL; }
	if(!fInputAOD) {delete v0; v0=NULL;}

      } // end loop on V0's
    } 
  
    // If there is less than 2 particles continue
    if(trkEntries<2) {
      AliDebug(1,Form(" Not enough tracks: %d",trkEntries));
      continue;
    }

    if(postrack1->Charge()<0 && !fLikeSign) continue;

    // LOOP ON  NEGATIVE  TRACKS
    for(iTrkN1=0; iTrkN1<nSeleTrks; iTrkN1++) {

      //if(iTrkN1%1==0) AliDebug(1,Form("    1st loop on neg: track number %d of %d",iTrkN1,nSeleTrks));  
      //if(iTrkN1%1==0) printf("    1st loop on neg: track number %d of %d\n",iTrkN1,nSeleTrks);  

      if(iTrkN1==iTrkP1) continue;

      // get track from tracks array
      negtrack1 = (AliESDtrack*)seleTrksArray.UncheckedAt(iTrkN1);

      if(negtrack1->Charge()>0 && !fLikeSign) continue;

      if(!TESTBIT(seleFlags[iTrkN1],kBitDispl)) continue;

      if(fMixEvent) {
	if(evtNumber[iTrkP1]==evtNumber[iTrkN1]) continue;
      }

      if(postrack1->Charge()==negtrack1->Charge()) { // like-sign 
	isLikeSign2Prong=kTRUE;
	if(!fLikeSign)    continue;
	if(iTrkN1<iTrkP1) continue; // this is needed to avoid double-counting of like-sign
      } else { // unlike-sign
	isLikeSign2Prong=kFALSE;
	if(postrack1->Charge()<0 || negtrack1->Charge()>0) continue;  // this is needed to avoid double-counting of unlike-sign
	if(fMixEvent) {
	  if(evtNumber[iTrkP1]==evtNumber[iTrkN1]) continue;
	}
       
      }

      // back to primary vertex
      //      postrack1->PropagateToDCA(fV1,fBzkG,kVeryBig);
      //      negtrack1->PropagateToDCA(fV1,fBzkG,kVeryBig);
      SetParametersAtVertex(postrack1,(AliExternalTrackParam*)tracksAtVertex.UncheckedAt(iTrkP1));
      SetParametersAtVertex(negtrack1,(AliExternalTrackParam*)tracksAtVertex.UncheckedAt(iTrkN1));
      negtrack1->GetPxPyPz(momneg1);

      // DCA between the two tracks
      dcap1n1 = postrack1->GetDCA(negtrack1,fBzkG,xdummy,ydummy);
      if(dcap1n1>dcaMax) { negtrack1=0; continue; }

      // Vertexing
      twoTrackArray1->AddAt(postrack1,0);
      twoTrackArray1->AddAt(negtrack1,1);
      AliAODVertex *vertexp1n1 = ReconstructSecondaryVertex(twoTrackArray1,dispersion);
      if(!vertexp1n1) {
	twoTrackArray1->Clear();
	negtrack1=0; 
	continue; 
      }

      // 2 prong candidate
      if(fD0toKpi || fJPSItoEle || fDstar || fLikeSign) { 
      
	io2Prong = Make2Prong(twoTrackArray1,event,vertexp1n1,dcap1n1,okD0,okJPSI,okD0fromDstar);
      
	if((fD0toKpi && okD0) || (fJPSItoEle && okJPSI) || (isLikeSign2Prong && (okD0 || okJPSI))) {
	  // add the vertex and the decay to the AOD
	  AliAODVertex *v2Prong = new(verticesHFRef[iVerticesHF++])AliAODVertex(*vertexp1n1);
	  if(!isLikeSign2Prong) {
	    if(okD0) {  
	      rd = new(aodD0toKpiRef[iD0toKpi++])AliAODRecoDecayHF2Prong(*io2Prong);
	      rd->SetSecondaryVtx(v2Prong);
	      v2Prong->SetParent(rd);
	      AddRefs(v2Prong,rd,event,twoTrackArray1);
	    }
	    if(okJPSI) {
	      rd = new(aodJPSItoEleRef[iJPSItoEle++])AliAODRecoDecayHF2Prong(*io2Prong);
	      rd->SetSecondaryVtx(v2Prong);
	      if(!okD0) v2Prong->SetParent(rd); // it cannot have two mothers ...
	      AddRefs(v2Prong,rd,event,twoTrackArray1);
	    }
	  } else { // isLikeSign2Prong
	    rd = new(aodLikeSign2ProngRef[iLikeSign2Prong++])AliAODRecoDecayHF2Prong(*io2Prong);
	    rd->SetSecondaryVtx(v2Prong);
	    v2Prong->SetParent(rd);
	    AddRefs(v2Prong,rd,event,twoTrackArray1);
	  }
	  // Set selection bit for PID
	  if(okD0) SetSelectionBitForPID(fCutsD0toKpi,rd,AliRDHFCuts::kD0toKpiPID);
	}
	// D* candidates
	if(fDstar && okD0fromDstar && !isLikeSign2Prong) {
	  // write references in io2Prong
	  if(fInputAOD) {
	    AddDaughterRefs(vertexp1n1,event,twoTrackArray1);
	  } else {
	    vertexp1n1->AddDaughter(postrack1);
	    vertexp1n1->AddDaughter(negtrack1);
	  }
	  io2Prong->SetSecondaryVtx(vertexp1n1);
	  //printf("--->  %d %d %d %d %d\n",vertexp1n1->GetNDaughters(),iTrkP1,iTrkN1,postrack1->Charge(),negtrack1->Charge());
	  // create a track from the D0
	  AliNeutralTrackParam *trackD0 = new AliNeutralTrackParam(io2Prong);
	  
	  // LOOP ON TRACKS THAT PASSED THE SOFT PION CUTS
	  for(iTrkSoftPi=0; iTrkSoftPi<nSeleTrks; iTrkSoftPi++) {

	    if(iTrkSoftPi==iTrkP1 || iTrkSoftPi==iTrkN1) continue;

	    if(!TESTBIT(seleFlags[iTrkSoftPi],kBitSoftPi)) continue;

	    if(fMixEvent) {
	      if(evtNumber[iTrkP1]==evtNumber[iTrkSoftPi] || 
		 evtNumber[iTrkN1]==evtNumber[iTrkSoftPi] || 
		 evtNumber[iTrkP1]==evtNumber[iTrkN1]) continue;
	    }

	    //if(iTrkSoftPi%1==0) AliDebug(1,Form("    1st loop on pi_s: track number %d of %d",iTrkSoftPi,nSeleTrks));  

	    trackD0->PropagateToDCA(fV1,fBzkG,kVeryBig);
	    if(trackD0->GetSigmaY2()<0. || trackD0->GetSigmaZ2()<0.) continue; // this is insipired by the AliITStrackV2::Invariant() checks

	    // get track from tracks array
	    trackPi = (AliESDtrack*)seleTrksArray.UncheckedAt(iTrkSoftPi);
	    //	    trackPi->PropagateToDCA(fV1,fBzkG,kVeryBig);
	    SetParametersAtVertex(trackPi,(AliExternalTrackParam*)tracksAtVertex.UncheckedAt(iTrkSoftPi));
	    twoTrackArrayCasc->AddAt(trackPi,0);
	    twoTrackArrayCasc->AddAt(trackD0,1);
	    if(!SelectInvMassAndPtDstarD0pi(twoTrackArrayCasc)){
	      twoTrackArrayCasc->Clear();
	      trackPi=0; 
	      continue; 
	    }

	    AliAODVertex *vertexCasc = 0;

	    if(fFindVertexForDstar) {
	      // DCA between the two tracks
	      dcaCasc = trackPi->GetDCA(trackD0,fBzkG,xdummy,ydummy);
	      // Vertexing
	      vertexCasc = ReconstructSecondaryVertex(twoTrackArrayCasc,dispersion,kFALSE);
	    } else {
	      // assume Dstar decays at the primary vertex
	      Double_t pos[3],cov[6],chi2perNDF;
	      fV1->GetXYZ(pos);
	      fV1->GetCovMatrix(cov);
	      chi2perNDF = fV1->GetChi2toNDF();
	      vertexCasc = new AliAODVertex(pos,cov,chi2perNDF,0x0,-1,AliAODVertex::kUndef,2);
	      dcaCasc = 0.;
	    }
	    if(!vertexCasc) { 
	      twoTrackArrayCasc->Clear();
	      trackPi=0; 
	      continue; 
	    }

            ioCascade = MakeCascade(twoTrackArrayCasc,event,vertexCasc,io2Prong,dcaCasc,okDstar);
            if(okDstar) {
	      // add the D0 to the AOD (if not already done)
	      if(!okD0) {
		AliAODVertex *v2Prong = new(verticesHFRef[iVerticesHF++])AliAODVertex(*vertexp1n1);
	        rd = new(aodD0toKpiRef[iD0toKpi++])AliAODRecoDecayHF2Prong(*io2Prong);
		rd->SetSecondaryVtx(v2Prong);
		v2Prong->SetParent(rd);
		AddRefs(v2Prong,rd,event,twoTrackArray1);
		okD0=kTRUE; // this is done to add it only once
	      }
	      // add the vertex and the cascade to the AOD
	      AliAODVertex *vCasc = new(verticesHFRef[iVerticesHF++])AliAODVertex(*vertexCasc); 
	      rc = new(aodDstarRef[iDstar++])AliAODRecoCascadeHF(*ioCascade);
	      rc->SetSecondaryVtx(vCasc);
	      vCasc->SetParent(rc);
	      if(!fInputAOD) vCasc->AddDaughter(rd); // just to fill ref #0 
	      AddRefs(vCasc,rc,event,twoTrackArrayCasc);
	      vCasc->AddDaughter(rd); // add the D0 (in ref #1)
	      // Set selection bit for PID
	      SetSelectionBitForPID(fCutsDStartoKpipi,rc,AliRDHFCuts::kDstarPID);
	    }
	    twoTrackArrayCasc->Clear();
	    trackPi=0; 
	    if(ioCascade) {delete ioCascade; ioCascade=NULL;}
	    delete vertexCasc; vertexCasc=NULL;
	  } // end loop on soft pi tracks

	  if(trackD0) {delete trackD0; trackD0=NULL;}

	}
	if(io2Prong) {delete io2Prong; io2Prong=NULL;}
      }      

      twoTrackArray1->Clear(); 
      if( (!f3Prong && !f4Prong) || 
	  (isLikeSign2Prong && !f3Prong) ) { 
	negtrack1=0; 
	delete vertexp1n1; 
	continue; 
      }

	
      // 2nd LOOP  ON  POSITIVE  TRACKS 
      for(iTrkP2=iTrkP1+1; iTrkP2<nSeleTrks; iTrkP2++) {

	if(iTrkP2==iTrkP1 || iTrkP2==iTrkN1) continue;

	//if(iTrkP2%1==0) AliDebug(1,Form("    2nd loop on pos: track number %d of %d",iTrkP2,nSeleTrks));  

	// get track from tracks array
	postrack2 = (AliESDtrack*)seleTrksArray.UncheckedAt(iTrkP2);

	if(postrack2->Charge()<0) continue; 

	if(!TESTBIT(seleFlags[iTrkP2],kBitDispl)) continue;

	// Check single tracks cuts specific for 3 prongs
	if(!TESTBIT(seleFlags[iTrkP2],kBit3Prong)) continue;
	if(!TESTBIT(seleFlags[iTrkP1],kBit3Prong)) continue;
	if(!TESTBIT(seleFlags[iTrkN1],kBit3Prong)) continue;

	if(fMixEvent) {
	  if(evtNumber[iTrkP1]==evtNumber[iTrkP2] || 
	     evtNumber[iTrkN1]==evtNumber[iTrkP2] ||
	     evtNumber[iTrkP1]==evtNumber[iTrkN1]) continue;
	}

	if(isLikeSign2Prong) { // like-sign pair -> have to build only like-sign triplet 
	  if(!fLikeSign3prong) continue;
	  if(postrack1->Charge()>0) { // ok: like-sign triplet (+++)
	    isLikeSign3Prong=kTRUE;
	  } else { // not ok
	    continue;
	  }
	} else { // normal triplet (+-+)
	  isLikeSign3Prong=kFALSE; 
	  if(fMixEvent) {
	    if(evtNumber[iTrkP1]==evtNumber[iTrkP2] || 
	       evtNumber[iTrkN1]==evtNumber[iTrkP2] ||
	       evtNumber[iTrkP1]==evtNumber[iTrkN1]) continue;
	  }
	}

	if(fUseKaonPIDfor3Prong){
	  if(!TESTBIT(seleFlags[iTrkN1],kBitKaonCompat)) continue;
	}
	Bool_t okForLcTopKpi=kTRUE;
	Int_t pidLcStatus=3; // 3= OK as pKpi and Kpipi
	if(fUsePIDforLc>0){
	  if(!TESTBIT(seleFlags[iTrkP1],kBitProtonCompat) &&
	     !TESTBIT(seleFlags[iTrkP2],kBitProtonCompat) ){
	    okForLcTopKpi=kFALSE;
	    pidLcStatus=0;
	  }
	  if(okForLcTopKpi && fUsePIDforLc>1){
	    okForLcTopKpi=kFALSE;
	    pidLcStatus=0;
	    if(TESTBIT(seleFlags[iTrkP1],kBitProtonCompat) &&
	       TESTBIT(seleFlags[iTrkP2],kBitPionCompat) ){
	      okForLcTopKpi=kTRUE;
	      pidLcStatus+=1; // 1= OK as pKpi
	    }
	    if(TESTBIT(seleFlags[iTrkP2],kBitProtonCompat) &&
	       TESTBIT(seleFlags[iTrkP1],kBitPionCompat) ){
	      okForLcTopKpi=kTRUE;
	      pidLcStatus+=2; // 2= OK as piKp
	    }
	  }
	}
	Bool_t okForDsToKKpi=kTRUE;
	if(fUseKaonPIDforDs){
	  if(!TESTBIT(seleFlags[iTrkP1],kBitKaonCompat) &&
	     !TESTBIT(seleFlags[iTrkP2],kBitKaonCompat) ) okForDsToKKpi=kFALSE;
	}
	// back to primary vertex
	//	postrack1->PropagateToDCA(fV1,fBzkG,kVeryBig);
	//	postrack2->PropagateToDCA(fV1,fBzkG,kVeryBig);
	//	negtrack1->PropagateToDCA(fV1,fBzkG,kVeryBig);
	SetParametersAtVertex(postrack1,(AliExternalTrackParam*)tracksAtVertex.UncheckedAt(iTrkP1));
	SetParametersAtVertex(negtrack1,(AliExternalTrackParam*)tracksAtVertex.UncheckedAt(iTrkN1));
	SetParametersAtVertex(postrack2,(AliExternalTrackParam*)tracksAtVertex.UncheckedAt(iTrkP2));
      
	//printf("********** %d %d %d\n",postrack1->GetID(),postrack2->GetID(),negtrack1->GetID());

	dcap2n1 = postrack2->GetDCA(negtrack1,fBzkG,xdummy,ydummy);
	if(dcap2n1>dcaMax) { postrack2=0; continue; }
	dcap1p2 = postrack2->GetDCA(postrack1,fBzkG,xdummy,ydummy);
	if(dcap1p2>dcaMax) { postrack2=0; continue; }

	// check invariant mass cuts for D+,Ds,Lc
        massCutOK=kTRUE;
	if(f3Prong) {
	  if(postrack2->Charge()>0) {
	    threeTrackArray->AddAt(postrack1,0);
	    threeTrackArray->AddAt(negtrack1,1);
	    threeTrackArray->AddAt(postrack2,2);
	  } else {
	    threeTrackArray->AddAt(negtrack1,0);
	    threeTrackArray->AddAt(postrack1,1);
	    threeTrackArray->AddAt(postrack2,2);
	  }
	  if(fMassCutBeforeVertexing){
	    postrack2->GetPxPyPz(mompos2);
	    Double_t pxDau[3]={mompos1[0],momneg1[0],mompos2[0]};
	    Double_t pyDau[3]={mompos1[1],momneg1[1],mompos2[1]};
	    Double_t pzDau[3]={mompos1[2],momneg1[2],mompos2[2]};
	    //	    massCutOK = SelectInvMassAndPt3prong(threeTrackArray);
	    massCutOK = SelectInvMassAndPt3prong(pxDau,pyDau,pzDau,pidLcStatus);
	  }
	}

	if(f3Prong && !massCutOK) {
	  threeTrackArray->Clear();
	  if(!f4Prong) { 
	    postrack2=0; 
	    continue;
	  } 
	} 
	
	// Vertexing
	twoTrackArray2->AddAt(postrack2,0);
	twoTrackArray2->AddAt(negtrack1,1);
	AliAODVertex *vertexp2n1 = ReconstructSecondaryVertex(twoTrackArray2,dispersion);
	if(!vertexp2n1) { 
	  twoTrackArray2->Clear();
	  postrack2=0; 
	  continue;
	}

	// 3 prong candidates
	if(f3Prong && massCutOK) { 

	  AliAODVertex* secVert3PrAOD = ReconstructSecondaryVertex(threeTrackArray,dispersion);
	  io3Prong = Make3Prong(threeTrackArray,event,secVert3PrAOD,dispersion,vertexp1n1,vertexp2n1,dcap1n1,dcap2n1,dcap1p2,okForLcTopKpi,okForDsToKKpi,ok3Prong);
	  if(ok3Prong) {
	    AliAODVertex *v3Prong = new(verticesHFRef[iVerticesHF++])AliAODVertex(*secVert3PrAOD);
	    if(!isLikeSign3Prong) {
	      rd = new(aodCharm3ProngRef[i3Prong++])AliAODRecoDecayHF3Prong(*io3Prong);
	      rd->SetSecondaryVtx(v3Prong);
	      v3Prong->SetParent(rd);
	      AddRefs(v3Prong,rd,event,threeTrackArray);
	    } else { // isLikeSign3Prong
	      if(fLikeSign3prong){
		rd = new(aodLikeSign3ProngRef[iLikeSign3Prong++])AliAODRecoDecayHF3Prong(*io3Prong);
		rd->SetSecondaryVtx(v3Prong);
		v3Prong->SetParent(rd);
		AddRefs(v3Prong,rd,event,threeTrackArray);
	      }
	    }
	    // Set selection bit for PID
	    SetSelectionBitForPID(fCutsDplustoKpipi,rd,AliRDHFCuts::kDplusPID);
	    SetSelectionBitForPID(fCutsDstoKKpi,rd,AliRDHFCuts::kDsPID);
	    SetSelectionBitForPID(fCutsLctopKpi,rd,AliRDHFCuts::kLcPID);
	  }
	  if(io3Prong) {delete io3Prong; io3Prong=NULL;} 
	  if(secVert3PrAOD) {delete secVert3PrAOD; secVert3PrAOD=NULL;} 
	}

	// 4 prong candidates
	if(f4Prong 
	   // don't make 4 prong with like-sign pairs and triplets
	   && !isLikeSign2Prong && !isLikeSign3Prong
	   // track-to-track dca cuts already now
	   && dcap1n1 < fCutsD0toKpipipi->GetDCACut()
	   && dcap2n1 < fCutsD0toKpipipi->GetDCACut()) {

	  // back to primary vertex
	  //	  postrack1->PropagateToDCA(fV1,fBzkG,kVeryBig);
	  //	  postrack2->PropagateToDCA(fV1,fBzkG,kVeryBig);
	  //	  negtrack1->PropagateToDCA(fV1,fBzkG,kVeryBig);
	  SetParametersAtVertex(postrack1,(AliExternalTrackParam*)tracksAtVertex.UncheckedAt(iTrkP1));
	  SetParametersAtVertex(negtrack1,(AliExternalTrackParam*)tracksAtVertex.UncheckedAt(iTrkN1));
	  SetParametersAtVertex(postrack2,(AliExternalTrackParam*)tracksAtVertex.UncheckedAt(iTrkP2));

	  // Vertexing for these 3 (can be taken from above?)
          threeTrackArray->AddAt(postrack1,0);
          threeTrackArray->AddAt(negtrack1,1);
	  threeTrackArray->AddAt(postrack2,2);
          AliAODVertex* vertexp1n1p2 = ReconstructSecondaryVertex(threeTrackArray,dispersion);

	  // 3rd LOOP  ON  NEGATIVE  TRACKS (for 4 prong) 
	  for(iTrkN2=iTrkN1+1; iTrkN2<nSeleTrks; iTrkN2++) {

	    if(iTrkN2==iTrkP1 || iTrkN2==iTrkP2 || iTrkN2==iTrkN1) continue;

	    //if(iTrkN2%1==0) AliDebug(1,Form("    3rd loop on neg: track number %d of %d",iTrkN2,nSeleTrks));  

	    // get track from tracks array
	    negtrack2 = (AliESDtrack*)seleTrksArray.UncheckedAt(iTrkN2);

	    if(negtrack2->Charge()>0) continue;

	    if(!TESTBIT(seleFlags[iTrkN2],kBitDispl)) continue;
	    if(fMixEvent){ 
	      if(evtNumber[iTrkP1]==evtNumber[iTrkN2] || 
		 evtNumber[iTrkN1]==evtNumber[iTrkN2] || 
		 evtNumber[iTrkP2]==evtNumber[iTrkN2] ||
		 evtNumber[iTrkP1]==evtNumber[iTrkN1] ||
		 evtNumber[iTrkP1]==evtNumber[iTrkP2] ||
		 evtNumber[iTrkN1]==evtNumber[iTrkP2]) continue;
	    }

	    // back to primary vertex
	    // postrack1->PropagateToDCA(fV1,fBzkG,kVeryBig);
	    // postrack2->PropagateToDCA(fV1,fBzkG,kVeryBig);
	    // negtrack1->PropagateToDCA(fV1,fBzkG,kVeryBig);
	    // negtrack2->PropagateToDCA(fV1,fBzkG,kVeryBig);
	    SetParametersAtVertex(postrack1,(AliExternalTrackParam*)tracksAtVertex.UncheckedAt(iTrkP1));
	    SetParametersAtVertex(negtrack1,(AliExternalTrackParam*)tracksAtVertex.UncheckedAt(iTrkN1));
	    SetParametersAtVertex(postrack2,(AliExternalTrackParam*)tracksAtVertex.UncheckedAt(iTrkP2));
	    SetParametersAtVertex(negtrack2,(AliExternalTrackParam*)tracksAtVertex.UncheckedAt(iTrkN2));

	    dcap1n2 = postrack1->GetDCA(negtrack2,fBzkG,xdummy,ydummy);
	    if(dcap1n2 > fCutsD0toKpipipi->GetDCACut()) { negtrack2=0; continue; }
            dcap2n2 = postrack2->GetDCA(negtrack2,fBzkG,xdummy,ydummy);
            if(dcap2n2 > fCutsD0toKpipipi->GetDCACut()) { negtrack2=0; continue; }


	    fourTrackArray->AddAt(postrack1,0);
	    fourTrackArray->AddAt(negtrack1,1);
	    fourTrackArray->AddAt(postrack2,2);
	    fourTrackArray->AddAt(negtrack2,3);

	    // check invariant mass cuts for D0
	    massCutOK=kTRUE;
	    if(fMassCutBeforeVertexing) 
	      massCutOK = SelectInvMassAndPt4prong(fourTrackArray);
	    
	    if(!massCutOK) {
	      fourTrackArray->Clear(); 
	      negtrack2=0; 
	      continue; 
	    }

	    // Vertexing
	    AliAODVertex* secVert4PrAOD = ReconstructSecondaryVertex(fourTrackArray,dispersion);
	    io4Prong = Make4Prong(fourTrackArray,event,secVert4PrAOD,vertexp1n1,vertexp1n1p2,dcap1n1,dcap1n2,dcap2n1,dcap2n2,ok4Prong);
	    if(ok4Prong) {
	      AliAODVertex *v4Prong = new(verticesHFRef[iVerticesHF++])AliAODVertex(*secVert4PrAOD);
	      rd = new(aodCharm4ProngRef[i4Prong++])AliAODRecoDecayHF4Prong(*io4Prong);
	      rd->SetSecondaryVtx(v4Prong);
	      v4Prong->SetParent(rd);
	      AddRefs(v4Prong,rd,event,fourTrackArray);
	    }

	    if(io4Prong) {delete io4Prong; io4Prong=NULL;} 
	    if(secVert4PrAOD) {delete secVert4PrAOD; secVert4PrAOD=NULL;} 
	    fourTrackArray->Clear();
	    negtrack2 = 0;

	  } // end loop on negative tracks

          threeTrackArray->Clear();
	  delete vertexp1n1p2;

	}

	postrack2 = 0;
	delete vertexp2n1;

      } // end 2nd loop on positive tracks

      twoTrackArray2->Clear();
      
      // 2nd LOOP  ON  NEGATIVE  TRACKS (for 3 prong -+-)
      for(iTrkN2=iTrkN1+1; iTrkN2<nSeleTrks; iTrkN2++) {

	if(iTrkN2==iTrkP1 || iTrkN2==iTrkP2 || iTrkN2==iTrkN1) continue;

	//if(iTrkN2%1==0) AliDebug(1,Form("    2nd loop on neg: track number %d of %d",iTrkN2,nSeleTrks));  

	// get track from tracks array
	negtrack2 = (AliESDtrack*)seleTrksArray.UncheckedAt(iTrkN2);

	if(negtrack2->Charge()>0) continue;

	if(!TESTBIT(seleFlags[iTrkN2],kBitDispl)) continue;

	// Check single tracks cuts specific for 3 prongs
	if(!TESTBIT(seleFlags[iTrkN2],kBit3Prong)) continue;
	if(!TESTBIT(seleFlags[iTrkP1],kBit3Prong)) continue;
	if(!TESTBIT(seleFlags[iTrkN1],kBit3Prong)) continue;

	if(fMixEvent) {
	  if(evtNumber[iTrkP1]==evtNumber[iTrkN2] || 
	     evtNumber[iTrkN1]==evtNumber[iTrkN2] ||
	     evtNumber[iTrkP1]==evtNumber[iTrkN1]) continue;
	}

	if(isLikeSign2Prong) { // like-sign pair -> have to build only like-sign triplet 
	  if(!fLikeSign3prong) continue;
	  if(postrack1->Charge()<0) { // ok: like-sign triplet (---)
	    isLikeSign3Prong=kTRUE;
	  } else { // not ok
	    continue;
	  }
	} else { // normal triplet (-+-)
	  isLikeSign3Prong=kFALSE;
	}

	if(fUseKaonPIDfor3Prong){
	  if(!TESTBIT(seleFlags[iTrkP1],kBitKaonCompat)) continue;
	}
	Bool_t okForLcTopKpi=kTRUE;
	Int_t pidLcStatus=3; // 3= OK as pKpi and Kpipi
	if(fUsePIDforLc>0){
	  if(!TESTBIT(seleFlags[iTrkN1],kBitProtonCompat) &&
	     !TESTBIT(seleFlags[iTrkN2],kBitProtonCompat) ){
	    okForLcTopKpi=kFALSE;
	    pidLcStatus=0;
	  }
	  if(okForLcTopKpi && fUsePIDforLc>1){
	    okForLcTopKpi=kFALSE;
	    pidLcStatus=0;
	    if(TESTBIT(seleFlags[iTrkN1],kBitProtonCompat) &&
	       TESTBIT(seleFlags[iTrkN2],kBitPionCompat) ){
	      okForLcTopKpi=kTRUE;
	      pidLcStatus+=1; // 1= OK as pKpi
	    }
	    if(TESTBIT(seleFlags[iTrkN2],kBitProtonCompat) &&
	       TESTBIT(seleFlags[iTrkN1],kBitPionCompat) ){
	      okForLcTopKpi=kTRUE;
	      pidLcStatus+=2; // 2= OK as piKp
	    }
	  }
	}
	Bool_t okForDsToKKpi=kTRUE;
	if(fUseKaonPIDforDs){
	  if(!TESTBIT(seleFlags[iTrkN1],kBitKaonCompat) &&
	     !TESTBIT(seleFlags[iTrkN2],kBitKaonCompat) ) okForDsToKKpi=kFALSE;
	}

	// back to primary vertex
	// postrack1->PropagateToDCA(fV1,fBzkG,kVeryBig);
	// negtrack1->PropagateToDCA(fV1,fBzkG,kVeryBig);
	// negtrack2->PropagateToDCA(fV1,fBzkG,kVeryBig);
	SetParametersAtVertex(postrack1,(AliExternalTrackParam*)tracksAtVertex.UncheckedAt(iTrkP1));
	SetParametersAtVertex(negtrack1,(AliExternalTrackParam*)tracksAtVertex.UncheckedAt(iTrkN1));
	SetParametersAtVertex(negtrack2,(AliExternalTrackParam*)tracksAtVertex.UncheckedAt(iTrkN2));
	//printf("********** %d %d %d\n",postrack1->GetID(),negtrack1->GetID(),negtrack2->GetID());

	dcap1n2 = postrack1->GetDCA(negtrack2,fBzkG,xdummy,ydummy);
	if(dcap1n2>dcaMax) { negtrack2=0; continue; }
	dcan1n2 = negtrack1->GetDCA(negtrack2,fBzkG,xdummy,ydummy);
	if(dcan1n2>dcaMax) { negtrack2=0; continue; }

	threeTrackArray->AddAt(negtrack1,0);
	threeTrackArray->AddAt(postrack1,1);
	threeTrackArray->AddAt(negtrack2,2);

	// check invariant mass cuts for D+,Ds,Lc
        massCutOK=kTRUE;
	if(fMassCutBeforeVertexing && f3Prong){ 
	  negtrack2->GetPxPyPz(momneg2);
	  Double_t pxDau[3]={momneg1[0],mompos1[0],momneg2[0]};
	  Double_t pyDau[3]={momneg1[1],mompos1[1],momneg2[1]};
	  Double_t pzDau[3]={momneg1[2],mompos1[2],momneg2[2]};
	  //	  massCutOK = SelectInvMassAndPt3prong(threeTrackArray);
	  massCutOK = SelectInvMassAndPt3prong(pxDau,pyDau,pzDau,pidLcStatus);
	}
	if(!massCutOK) { 
	  threeTrackArray->Clear();
	  negtrack2=0; 
	  continue; 
	}
	
	// Vertexing
	twoTrackArray2->AddAt(postrack1,0);
	twoTrackArray2->AddAt(negtrack2,1);

	AliAODVertex *vertexp1n2 = ReconstructSecondaryVertex(twoTrackArray2,dispersion);
	if(!vertexp1n2) { 
	  twoTrackArray2->Clear();
	  negtrack2=0; 
	  continue; 
	}

	if(f3Prong) { 
	  AliAODVertex* secVert3PrAOD = ReconstructSecondaryVertex(threeTrackArray,dispersion);
	  io3Prong = Make3Prong(threeTrackArray,event,secVert3PrAOD,dispersion,vertexp1n1,vertexp1n2,dcap1n1,dcap1n2,dcan1n2,okForLcTopKpi,okForDsToKKpi,ok3Prong);
	  if(ok3Prong) {
	    AliAODVertex *v3Prong = new(verticesHFRef[iVerticesHF++])AliAODVertex(*secVert3PrAOD);
	    if(!isLikeSign3Prong) {
	      rd = new(aodCharm3ProngRef[i3Prong++])AliAODRecoDecayHF3Prong(*io3Prong);
	      rd->SetSecondaryVtx(v3Prong);
	      v3Prong->SetParent(rd);
	      AddRefs(v3Prong,rd,event,threeTrackArray);
	    } else { // isLikeSign3Prong
	      if(fLikeSign3prong){
		rd = new(aodLikeSign3ProngRef[iLikeSign3Prong++])AliAODRecoDecayHF3Prong(*io3Prong);
		rd->SetSecondaryVtx(v3Prong);
		v3Prong->SetParent(rd);
		AddRefs(v3Prong,rd,event,threeTrackArray);
	      }
	    }
	    // Set selection bit for PID
	    SetSelectionBitForPID(fCutsDplustoKpipi,rd,AliRDHFCuts::kDplusPID);
	    SetSelectionBitForPID(fCutsDstoKKpi,rd,AliRDHFCuts::kDsPID);
	    SetSelectionBitForPID(fCutsLctopKpi,rd,AliRDHFCuts::kLcPID);
	  }
	  if(io3Prong) {delete io3Prong; io3Prong=NULL;} 
	  if(secVert3PrAOD) {delete secVert3PrAOD; secVert3PrAOD=NULL;}
	}
	threeTrackArray->Clear();
	negtrack2 = 0;
	delete vertexp1n2;

      } // end 2nd loop on negative tracks
      
      twoTrackArray2->Clear();
      
      negtrack1 = 0;
      delete vertexp1n1; 
    } // end 1st loop on negative tracks
    
    postrack1 = 0;
  }  // end 1st loop on positive tracks


  AliDebug(1,Form(" Total HF vertices in event = %d;",
		  (Int_t)aodVerticesHFTClArr->GetEntriesFast()));
  if(fD0toKpi) {
    AliDebug(1,Form(" D0->Kpi in event = %d;",
		    (Int_t)aodD0toKpiTClArr->GetEntriesFast()));
  }
  if(fJPSItoEle) {
    AliDebug(1,Form(" JPSI->ee in event = %d;",
		    (Int_t)aodJPSItoEleTClArr->GetEntriesFast()));
  }
  if(f3Prong) {
    AliDebug(1,Form(" Charm->3Prong in event = %d;",
		    (Int_t)aodCharm3ProngTClArr->GetEntriesFast()));
  }
  if(f4Prong) {
    AliDebug(1,Form(" Charm->4Prong in event = %d;\n",
		    (Int_t)aodCharm4ProngTClArr->GetEntriesFast()));
  }
  if(fDstar) {
    AliDebug(1,Form(" D*->D0pi in event = %d;\n",
		    (Int_t)aodDstarTClArr->GetEntriesFast()));
  }
  if(fCascades){
    AliDebug(1,Form(" cascades -> v0 + track in event = %d;\n",
		    (Int_t)aodCascadesTClArr->GetEntriesFast()));
  }
  if(fLikeSign) {
    AliDebug(1,Form(" Like-sign 2Prong in event = %d;\n",
		    (Int_t)aodLikeSign2ProngTClArr->GetEntriesFast()));
  }
  if(fLikeSign3prong && f3Prong) {
    AliDebug(1,Form(" Like-sign 3Prong in event = %d;\n",
		    (Int_t)aodLikeSign3ProngTClArr->GetEntriesFast()));
  }
    

  twoTrackArray1->Delete();  delete twoTrackArray1;
  twoTrackArray2->Delete();  delete twoTrackArray2;
  twoTrackArrayCasc->Delete();  delete twoTrackArrayCasc;
  twoTrackArrayV0->Delete();  delete twoTrackArrayV0;
  threeTrackArray->Clear(); 
  threeTrackArray->Delete(); delete threeTrackArray;
  fourTrackArray->Delete();  delete fourTrackArray;
  delete [] seleFlags; seleFlags=NULL;
  if(evtNumber) {delete [] evtNumber; evtNumber=NULL;}
  tracksAtVertex.Delete();

  if(fInputAOD) {
    seleTrksArray.Delete(); 
    if(fAODMap) { delete [] fAODMap; fAODMap=NULL; }
  }
  

  //printf("Trks: total %d  sele %d\n",fnTrksTotal,fnSeleTrksTotal);

  return;
}
//----------------------------------------------------------------------------
void AliAnalysisVertexingHF::AddRefs(AliAODVertex *v,AliAODRecoDecayHF *rd,
				     const AliVEvent *event,
				     const TObjArray *trkArray) const
{
  // Add the AOD tracks as daughters of the vertex (TRef)
  // Also add the references to the primary vertex and to the cuts
  //AliCodeTimerAuto("",0);

  if(fInputAOD) {
    AddDaughterRefs(v,event,trkArray);
    rd->SetPrimaryVtxRef((AliAODVertex*)event->GetPrimaryVertex());
  }

  /*
  rd->SetListOfCutsRef((TList*)fListOfCuts);
  //fListOfCuts->Print();
  cout<<fListOfCuts<<endl;
  TList *l=(TList*)rd->GetListOfCuts();
  cout<<l<<endl;
  if(l) {l->Print(); }else{printf("error\n");}
  */

  return;
}	
//----------------------------------------------------------------------------
void AliAnalysisVertexingHF::AddDaughterRefs(AliAODVertex *v,
					     const AliVEvent *event,
					     const TObjArray *trkArray) const
{
  // Add the AOD tracks as daughters of the vertex (TRef)
  //AliCodeTimerAuto("",0);

  Int_t nDg = v->GetNDaughters();
  TObject *dg = 0;
  if(nDg) dg = v->GetDaughter(0);
  
  if(dg) return; // daughters already added

  Int_t nTrks = trkArray->GetEntriesFast();

  AliExternalTrackParam *track = 0;
  AliAODTrack *aodTrack = 0;
  Int_t id;

  for(Int_t i=0; i<nTrks; i++) {
    track = (AliExternalTrackParam*)trkArray->UncheckedAt(i);
    id = (Int_t)track->GetID();
    //printf("---> %d\n",id);
    if(id<0) continue; // this track is a AliAODRecoDecay
    aodTrack = dynamic_cast<AliAODTrack*>(event->GetTrack(fAODMap[id]));
    if(!aodTrack) AliFatal("Not a standard AOD");
    v->AddDaughter(aodTrack);
  }

  return;
}	
//---------------------------------------------------------------------------
void AliAnalysisVertexingHF::FixReferences(AliAODEvent *aod)  
{
  // Checks that the references to the daughter tracks are properly
  // assigned and reassigns them if needed
  //
  //AliCodeTimerAuto("",0);


  TClonesArray *inputArray=(TClonesArray*)aod->GetList()->FindObject("VerticesHF");
  if(!inputArray) return;

  AliAODTrack *track = 0;
  AliAODVertex *vertex = 0;

  Bool_t needtofix=kFALSE;
  for(Int_t iv=0; iv<inputArray->GetEntriesFast(); iv++) {
    vertex = (AliAODVertex*)inputArray->UncheckedAt(iv);
    for(Int_t id=0; id<vertex->GetNDaughters(); id++) {
      track = (AliAODTrack*)vertex->GetDaughter(id);
      if(!track->GetStatus()) needtofix=kTRUE;
    }
    if(needtofix) break;
  }

  if(!needtofix) return;


  printf("Fixing references\n");

  fAODMapSize = 100000;
  fAODMap = new Int_t[fAODMapSize];
  memset(fAODMap,0,sizeof(Int_t)*fAODMapSize);

  for(Int_t i=0; i<aod->GetNumberOfTracks(); i++) {
    track = dynamic_cast<AliAODTrack*>(aod->GetTrack(i));
    if(!track) AliFatal("Not a standard AOD");

    // skip pure ITS SA tracks
    if(track->GetStatus()&AliESDtrack::kITSpureSA) continue;

    // skip tracks without ITS
    if(!(track->GetStatus()&AliESDtrack::kITSin)) continue;

    // TEMPORARY: check that the cov matrix is there
    Double_t covtest[21];
    if(!track->GetCovarianceXYZPxPyPz(covtest)) continue;
    //

    Int_t ind = (Int_t)track->GetID();
    if (ind>-1 && ind < fAODMapSize) fAODMap[ind] = i;
  }


  Int_t ids[4]={-1,-1,-1,-1};
  for(Int_t iv=0; iv<inputArray->GetEntriesFast(); iv++) {
    Bool_t cascade=kFALSE;
    vertex = (AliAODVertex*)inputArray->UncheckedAt(iv);
    Int_t id=0;
    Int_t nDgs = vertex->GetNDaughters();
    for(id=0; id<nDgs; id++) {
      track = (AliAODTrack*)vertex->GetDaughter(id);
      if(track->Charge()==0) {cascade=kTRUE; continue;} // cascade
      ids[id]=(Int_t)track->GetID();
      vertex->RemoveDaughter(track);
    }
    if(cascade) continue;
    for(id=0; id<nDgs; id++) {
      if (ids[id]>-1 && ids[id] < fAODMapSize) {
	track = dynamic_cast<AliAODTrack*>(aod->GetTrack(fAODMap[ids[id]]));
	if(!track) AliFatal("Not a standard AOD");
	vertex->AddDaughter(track);
      }
    }
    
  }

  return;
}
//----------------------------------------------------------------------------
AliAODRecoCascadeHF* AliAnalysisVertexingHF::MakeCascade(
				   TObjArray *twoTrackArray,AliVEvent *event,
				   AliAODVertex *secVert,
				   AliAODRecoDecayHF2Prong *rd2Prong,
				   Double_t dca,
				   Bool_t &okDstar) 
{
  // Make the cascade as a 2Prong decay and check if it passes Dstar
  // reconstruction cuts
  //AliCodeTimerAuto("",0);

  okDstar = kFALSE;

  Bool_t dummy1,dummy2,dummy3;

  // We use Make2Prong to construct the AliAODRecoCascadeHF
  // (which inherits from AliAODRecoDecayHF2Prong) 
  AliAODRecoCascadeHF *theCascade = 
    (AliAODRecoCascadeHF*)Make2Prong(twoTrackArray,event,secVert,dca,
				     dummy1,dummy2,dummy3);
  if(!theCascade) return 0x0;

  // charge
  AliESDtrack *trackPi = (AliESDtrack*)twoTrackArray->UncheckedAt(0);
  theCascade->SetCharge(trackPi->Charge());

  //--- selection cuts
  //
  AliAODRecoCascadeHF *tmpCascade = new AliAODRecoCascadeHF(*theCascade);
  if(fInputAOD){
    Int_t idSoftPi=(Int_t)trackPi->GetID();
    if (idSoftPi > -1 && idSoftPi < fAODMapSize) {
      AliAODTrack* trackPiAOD=dynamic_cast<AliAODTrack*>(event->GetTrack(fAODMap[idSoftPi]));
      if(!trackPiAOD) AliFatal("Not a standard AOD");
      tmpCascade->GetSecondaryVtx()->AddDaughter(trackPiAOD);
    }
  }else{
    tmpCascade->GetSecondaryVtx()->AddDaughter(trackPi);
  }
  tmpCascade->GetSecondaryVtx()->AddDaughter(rd2Prong);

  AliAODVertex *primVertexAOD=0;
  if(!fRecoPrimVtxSkippingTrks && !fRmTrksFromPrimVtx) {
    // take event primary vertex
    primVertexAOD = PrimaryVertex(); 
    tmpCascade->SetOwnPrimaryVtx(primVertexAOD);
    rd2Prong->SetOwnPrimaryVtx(primVertexAOD);
  }
  // select D*->D0pi
  if(fDstar) {
    okDstar = (Bool_t)fCutsDStartoKpipi->IsSelected(tmpCascade,AliRDHFCuts::kCandidate);
    if(okDstar) theCascade->SetSelectionBit(AliRDHFCuts::kDstarCuts);
  }
  tmpCascade->GetSecondaryVtx()->RemoveDaughters();
  tmpCascade->UnsetOwnPrimaryVtx(); 
  delete tmpCascade; tmpCascade=NULL;
  if(!fRecoPrimVtxSkippingTrks && !fRmTrksFromPrimVtx && !fMixEvent) {
    rd2Prong->UnsetOwnPrimaryVtx();
  }
  if(primVertexAOD) {delete primVertexAOD; primVertexAOD=NULL;}
  //---

  
  return theCascade;
}


//----------------------------------------------------------------------------
AliAODRecoCascadeHF* AliAnalysisVertexingHF::MakeCascade(
				   TObjArray *twoTrackArray,AliVEvent *event,
				   AliAODVertex *secVert,
				   AliAODv0 *v0,
				   Double_t dca,
				   Bool_t &okCascades) 
{
  //
  // Make the cascade as a 2Prong decay and check if it passes 
  // cascades reconstruction cuts
  //AliCodeTimerAuto("",0);
  
  //  AliDebug(2,Form("         building the cascade"));
  okCascades= kFALSE; 
  Bool_t dummy1,dummy2,dummy3;

  // We use Make2Prong to construct the AliAODRecoCascadeHF
  // (which inherits from AliAODRecoDecayHF2Prong) 
  AliAODRecoCascadeHF *theCascade = 
    (AliAODRecoCascadeHF*)Make2Prong(twoTrackArray,event,secVert,dca,
				     dummy1,dummy2,dummy3);
  if(!theCascade) return 0x0;

  // bachelor track and charge
  AliESDtrack *trackBachelor = (AliESDtrack*)twoTrackArray->UncheckedAt(0);
  theCascade->SetCharge(trackBachelor->Charge());

  //--- selection cuts
  //

  AliAODRecoCascadeHF *tmpCascade = new AliAODRecoCascadeHF(*theCascade);  
  if(fInputAOD){
    Int_t idBachelor=(Int_t)trackBachelor->GetID();
    if (idBachelor > -1 && idBachelor < fAODMapSize) {
      AliAODTrack* trackBachelorAOD=dynamic_cast<AliAODTrack*>(event->GetTrack(fAODMap[idBachelor]));
      if(!trackBachelorAOD) AliFatal("Not a standard AOD");
      tmpCascade->GetSecondaryVtx()->AddDaughter(trackBachelorAOD);
    }
  }else{
    tmpCascade->GetSecondaryVtx()->AddDaughter(trackBachelor);
  }
  tmpCascade->GetSecondaryVtx()->AddDaughter(v0);
  
  AliAODVertex *primVertexAOD=0;
  if(!fRecoPrimVtxSkippingTrks && !fRmTrksFromPrimVtx) {
    // take event primary vertex
    primVertexAOD = PrimaryVertex(); 
    if(!primVertexAOD) primVertexAOD = (AliAODVertex*)event->GetPrimaryVertex(); 
    tmpCascade->SetOwnPrimaryVtx(primVertexAOD);
  }
  
  // select Cascades
  if(fCascades && fInputAOD){
    okCascades = (Bool_t)fCutsLctoV0->IsSelected(tmpCascade,AliRDHFCuts::kCandidate);
  }
  else { 
    //AliDebug(2,Form("The cascade is contructed from ESDs, no cuts are applied")); 
    okCascades=kTRUE; 
  }// no cuts implemented from ESDs
  tmpCascade->GetSecondaryVtx()->RemoveDaughters();
  tmpCascade->UnsetOwnPrimaryVtx(); 
  delete tmpCascade; tmpCascade=NULL;
  if(primVertexAOD) {delete primVertexAOD; primVertexAOD=NULL;}
  //---
  
  return theCascade;
}

//-----------------------------------------------------------------------------
AliAODRecoDecayHF2Prong *AliAnalysisVertexingHF::Make2Prong(
				   TObjArray *twoTrackArray,AliVEvent *event,
				   AliAODVertex *secVert,Double_t dca,
				   Bool_t &okD0,Bool_t &okJPSI,
				   Bool_t &okD0fromDstar) 
{
  // Make 2Prong candidates and check if they pass D0toKpi or BtoJPSI
  // reconstruction cuts
  // G.E.Bruno (J/psi), A.Dainese (D0->Kpi)
  //AliCodeTimerAuto("",0);

  okD0=kFALSE; okJPSI=kFALSE; okD0fromDstar=kFALSE;

  Double_t px[2],py[2],pz[2],d0[2],d0err[2];
  AliESDtrack *postrack = (AliESDtrack*)twoTrackArray->UncheckedAt(0);
  AliESDtrack *negtrack = (AliESDtrack*)twoTrackArray->UncheckedAt(1);

  // propagate tracks to secondary vertex, to compute inv. mass
  postrack->PropagateToDCA(secVert,fBzkG,kVeryBig);
  negtrack->PropagateToDCA(secVert,fBzkG,kVeryBig);

  Double_t momentum[3];
  postrack->GetPxPyPz(momentum);
  px[0] = momentum[0]; py[0] = momentum[1]; pz[0] = momentum[2]; 
  negtrack->GetPxPyPz(momentum);
  px[1] = momentum[0]; py[1] = momentum[1]; pz[1] = momentum[2]; 


  // invariant mass cut (try to improve coding here..)
  Bool_t okMassCut=kFALSE;
  if(!okMassCut && fD0toKpi)   if(SelectInvMassAndPtD0Kpi(px,py,pz)) okMassCut=kTRUE;
  if(!okMassCut && fJPSItoEle) if(SelectInvMassAndPtJpsiee(px,py,pz)) okMassCut=kTRUE;
  if(!okMassCut && fDstar)     if(SelectInvMassAndPtDstarD0pi(px,py,pz)) okMassCut=kTRUE;
  if(!okMassCut && fCascades)  if(SelectInvMassAndPtCascade(px,py,pz)) okMassCut=kTRUE;
  if(!okMassCut) {
    //AliDebug(2," candidate didn't pass mass cut");
    return 0x0;    
  }
  // primary vertex to be used by this candidate
  AliAODVertex *primVertexAOD  = PrimaryVertex(twoTrackArray,event);
  if(!primVertexAOD) return 0x0;


  Double_t d0z0[2],covd0z0[3];
  postrack->PropagateToDCA(primVertexAOD,fBzkG,kVeryBig,d0z0,covd0z0);
  d0[0] = d0z0[0];
  d0err[0] = TMath::Sqrt(covd0z0[0]);
  negtrack->PropagateToDCA(primVertexAOD,fBzkG,kVeryBig,d0z0,covd0z0);
  d0[1] = d0z0[0];
  d0err[1] = TMath::Sqrt(covd0z0[0]);
  
  // create the object AliAODRecoDecayHF2Prong
  AliAODRecoDecayHF2Prong *the2Prong = new AliAODRecoDecayHF2Prong(secVert,px,py,pz,d0,d0err,dca);
  the2Prong->SetOwnPrimaryVtx(primVertexAOD);
  UShort_t id[2]={(UShort_t)postrack->GetID(),(UShort_t)negtrack->GetID()};
  the2Prong->SetProngIDs(2,id);
  delete primVertexAOD; primVertexAOD=NULL;

 
  if(postrack->Charge()!=0 && negtrack->Charge()!=0) { // don't apply these cuts if it's a Dstar 

    // Add daughter references already here
    if(fInputAOD) AddDaughterRefs(secVert,(AliAODEvent*)event,twoTrackArray);

    // select D0->Kpi
    if(fD0toKpi)   {
      okD0 = (Bool_t)fCutsD0toKpi->IsSelected(the2Prong,AliRDHFCuts::kCandidate,(AliAODEvent*)event);
      if(okD0) the2Prong->SetSelectionBit(AliRDHFCuts::kD0toKpiCuts);
    }
    //if(fDebug && fD0toKpi) printf("   %d\n",(Int_t)okD0);
    // select J/psi from B
    if(fJPSItoEle)   {
      okJPSI = (Bool_t)fCutsJpsitoee->IsSelected(the2Prong,AliRDHFCuts::kCandidate);
    }
    //if(fDebug && fJPSItoEle) printf("   %d\n",(Int_t)okJPSI);
    // select D0->Kpi from Dstar
    if(fDstar)   {
      okD0fromDstar = (Bool_t)fCutsDStartoKpipi->IsD0FromDStarSelected(the2Prong->Pt(),the2Prong,AliRDHFCuts::kCandidate);
      if(okD0fromDstar) the2Prong->SetSelectionBit(AliRDHFCuts::kD0fromDstarCuts);
    }
    //if(fDebug && fDstar) printf("   %d\n",(Int_t)okD0fromDstar);
  }


  // remove the primary vertex (was used only for selection)
  if(!fRecoPrimVtxSkippingTrks && !fRmTrksFromPrimVtx && !fMixEvent) {
    the2Prong->UnsetOwnPrimaryVtx();
  }
  
  // get PID info from ESD
  Double_t esdpid0[5]={0.,0.,0.,0.,0.};
  if(postrack->GetStatus()&AliESDtrack::kESDpid) postrack->GetESDpid(esdpid0);
  Double_t esdpid1[5]={0.,0.,0.,0.,0.};
  if(negtrack->GetStatus()&AliESDtrack::kESDpid) negtrack->GetESDpid(esdpid1);
  Double_t esdpid[10];
  for(Int_t i=0;i<5;i++) {
    esdpid[i]   = esdpid0[i];
    esdpid[5+i] = esdpid1[i];
  }
  the2Prong->SetPID(2,esdpid);

  return the2Prong;  
}
//----------------------------------------------------------------------------
AliAODRecoDecayHF3Prong* AliAnalysisVertexingHF::Make3Prong(
                             TObjArray *threeTrackArray,AliVEvent *event,
			     AliAODVertex *secVert,Double_t dispersion,
			     const AliAODVertex *vertexp1n1,const AliAODVertex *vertexp2n1,
			     Double_t dcap1n1,Double_t dcap2n1,Double_t dcap1p2,
			     Bool_t useForLc, Bool_t useForDs, Bool_t &ok3Prong) 
{
  // Make 3Prong candidates and check if they pass Dplus or Ds or Lambdac
  // reconstruction cuts 
  // E.Bruna, F.Prino

  //AliCodeTimerAuto("",0);

  ok3Prong=kFALSE;
  if(!secVert || !vertexp1n1 || !vertexp2n1) return 0x0; 

  Double_t px[3],py[3],pz[3],d0[3],d0err[3];
  Double_t momentum[3];


  AliESDtrack *postrack1 = (AliESDtrack*)threeTrackArray->UncheckedAt(0);
  AliESDtrack *negtrack  = (AliESDtrack*)threeTrackArray->UncheckedAt(1);
  AliESDtrack *postrack2 = (AliESDtrack*)threeTrackArray->UncheckedAt(2);

  postrack1->PropagateToDCA(secVert,fBzkG,kVeryBig);
  negtrack->PropagateToDCA(secVert,fBzkG,kVeryBig);
  postrack2->PropagateToDCA(secVert,fBzkG,kVeryBig);
  postrack1->GetPxPyPz(momentum);
  px[0] = momentum[0]; py[0] = momentum[1]; pz[0] = momentum[2]; 
  negtrack->GetPxPyPz(momentum);
  px[1] = momentum[0]; py[1] = momentum[1]; pz[1] = momentum[2]; 
  postrack2->GetPxPyPz(momentum);
  px[2] = momentum[0]; py[2] = momentum[1]; pz[2] = momentum[2]; 

  // invariant mass cut for D+, Ds, Lc
  Bool_t okMassCut=kFALSE;
  if(fMassCutBeforeVertexing) okMassCut=kTRUE; // mass cut already done and passed 
  if(!okMassCut && f3Prong) if(SelectInvMassAndPt3prong(px,py,pz)) okMassCut=kTRUE;
  if(!okMassCut) {
    //AliDebug(2," candidate didn't pass mass cut");
    return 0x0;    
  }

  // primary vertex to be used by this candidate
  AliAODVertex *primVertexAOD  = PrimaryVertex(threeTrackArray,event);
  if(!primVertexAOD) return 0x0;

  Double_t d0z0[2],covd0z0[3];
  postrack1->PropagateToDCA(primVertexAOD,fBzkG,kVeryBig,d0z0,covd0z0);
  d0[0]=d0z0[0];
  d0err[0] = TMath::Sqrt(covd0z0[0]);
  negtrack->PropagateToDCA(primVertexAOD,fBzkG,kVeryBig,d0z0,covd0z0);
  d0[1]=d0z0[0];
  d0err[1] = TMath::Sqrt(covd0z0[0]);
  postrack2->PropagateToDCA(primVertexAOD,fBzkG,kVeryBig,d0z0,covd0z0);
  d0[2]=d0z0[0];
  d0err[2] = TMath::Sqrt(covd0z0[0]);


  // create the object AliAODRecoDecayHF3Prong
  Double_t pos[3]; primVertexAOD->GetXYZ(pos);
  Double_t dca[3]={dcap1n1,dcap2n1,dcap1p2};
  Double_t dist12=TMath::Sqrt((vertexp1n1->GetX()-pos[0])*(vertexp1n1->GetX()-pos[0])+(vertexp1n1->GetY()-pos[1])*(vertexp1n1->GetY()-pos[1])+(vertexp1n1->GetZ()-pos[2])*(vertexp1n1->GetZ()-pos[2]));
  Double_t dist23=TMath::Sqrt((vertexp2n1->GetX()-pos[0])*(vertexp2n1->GetX()-pos[0])+(vertexp2n1->GetY()-pos[1])*(vertexp2n1->GetY()-pos[1])+(vertexp2n1->GetZ()-pos[2])*(vertexp2n1->GetZ()-pos[2]));
  Short_t charge=(Short_t)(postrack1->Charge()+postrack2->Charge()+negtrack->Charge());
  AliAODRecoDecayHF3Prong *the3Prong = new AliAODRecoDecayHF3Prong(secVert,px,py,pz,d0,d0err,dca,dispersion,dist12,dist23,charge);
  the3Prong->SetOwnPrimaryVtx(primVertexAOD);
  UShort_t id[3]={(UShort_t)postrack1->GetID(),(UShort_t)negtrack->GetID(),(UShort_t)postrack2->GetID()};
  the3Prong->SetProngIDs(3,id);

  delete primVertexAOD; primVertexAOD=NULL;

  // Add daughter references already here
  if(fInputAOD) AddDaughterRefs(secVert,(AliAODEvent*)event,threeTrackArray);

  // select D+->Kpipi, Ds->KKpi, Lc->pKpi
  if(f3Prong) {
    ok3Prong = kFALSE;
    
    if(fOKInvMassDplus && fCutsDplustoKpipi->IsSelected(the3Prong,AliRDHFCuts::kCandidate,(AliAODEvent*)event)) {
      ok3Prong = kTRUE;
      the3Prong->SetSelectionBit(AliRDHFCuts::kDplusCuts);
    }
    if(useForDs && fOKInvMassDs){
      if(fCutsDstoKKpi->IsSelected(the3Prong,AliRDHFCuts::kCandidate,(AliAODEvent*)event)) {
	ok3Prong = kTRUE;
	the3Prong->SetSelectionBit(AliRDHFCuts::kDsCuts);
      }
    }
    if(useForLc && fOKInvMassLc){
      if(fCutsLctopKpi->IsSelected(the3Prong,AliRDHFCuts::kCandidate,(AliAODEvent*)event)) {
	ok3Prong = kTRUE;
	the3Prong->SetSelectionBit(AliRDHFCuts::kLcCuts);
      } 
    }
  }
  //if(fDebug) printf("ok3Prong: %d\n",(Int_t)ok3Prong);

  if(!fRecoPrimVtxSkippingTrks && !fRmTrksFromPrimVtx && !fMixEvent) {
    the3Prong->UnsetOwnPrimaryVtx();
  }

  // get PID info from ESD
  Double_t esdpid0[5]={0.,0.,0.,0.,0.};
  if(postrack1->GetStatus()&AliESDtrack::kESDpid) postrack1->GetESDpid(esdpid0);
  Double_t esdpid1[5]={0.,0.,0.,0.,0.};
  if(negtrack->GetStatus()&AliESDtrack::kESDpid) negtrack->GetESDpid(esdpid1);
  Double_t esdpid2[5]={0.,0.,0.,0.,0.};
  if(postrack2->GetStatus()&AliESDtrack::kESDpid) postrack2->GetESDpid(esdpid2);
  
  Double_t esdpid[15];
  for(Int_t i=0;i<5;i++) {
    esdpid[i]    = esdpid0[i];
    esdpid[5+i]  = esdpid1[i];
    esdpid[10+i] = esdpid2[i];
  }
  the3Prong->SetPID(3,esdpid);

  return the3Prong;
}
//----------------------------------------------------------------------------
AliAODRecoDecayHF4Prong* AliAnalysisVertexingHF::Make4Prong(
                             TObjArray *fourTrackArray,AliVEvent *event,
                             AliAODVertex *secVert,
                             const AliAODVertex *vertexp1n1,
                             const AliAODVertex *vertexp1n1p2,
                             Double_t dcap1n1,Double_t dcap1n2,
			     Double_t dcap2n1,Double_t dcap2n2,
                             Bool_t &ok4Prong) 
{
  // Make 4Prong candidates and check if they pass D0toKpipipi
  // reconstruction cuts
  // G.E.Bruno, R.Romita
  //AliCodeTimerAuto("",0);

  ok4Prong=kFALSE;
  if(!secVert || !vertexp1n1 || !vertexp1n1p2) return 0x0; 

  Double_t px[4],py[4],pz[4],d0[4],d0err[4];//d0z[3];

  AliESDtrack *postrack1 = (AliESDtrack*)fourTrackArray->UncheckedAt(0);
  AliESDtrack *negtrack1 = (AliESDtrack*)fourTrackArray->UncheckedAt(1);
  AliESDtrack *postrack2 = (AliESDtrack*)fourTrackArray->UncheckedAt(2);
  AliESDtrack *negtrack2 = (AliESDtrack*)fourTrackArray->UncheckedAt(3);

  postrack1->PropagateToDCA(secVert,fBzkG,kVeryBig);
  negtrack1->PropagateToDCA(secVert,fBzkG,kVeryBig);
  postrack2->PropagateToDCA(secVert,fBzkG,kVeryBig);
  negtrack2->PropagateToDCA(secVert,fBzkG,kVeryBig);

  Double_t momentum[3];
  postrack1->GetPxPyPz(momentum);
  px[0] = momentum[0]; py[0] = momentum[1]; pz[0] = momentum[2];
  negtrack1->GetPxPyPz(momentum);
  px[1] = momentum[0]; py[1] = momentum[1]; pz[1] = momentum[2];
  postrack2->GetPxPyPz(momentum);
  px[2] = momentum[0]; py[2] = momentum[1]; pz[2] = momentum[2];
  negtrack2->GetPxPyPz(momentum);
  px[3] = momentum[0]; py[3] = momentum[1]; pz[3] = momentum[2];

  // invariant mass cut for rho or D0 (try to improve coding here..)
  Bool_t okMassCut=kFALSE;
  if(fMassCutBeforeVertexing) okMassCut=kTRUE; // mass cut already done and passed 
  if(!okMassCut && !(fCutsD0toKpipipi->GetUsePID())) {      //no PID, to be implemented with PID
    if(SelectInvMassAndPt4prong(px,py,pz)) okMassCut=kTRUE;
  }
  if(!okMassCut) {
    //if(fDebug) printf(" candidate didn't pass mass cut\n");
    //printf(" candidate didn't pass mass cut\n");
    return 0x0;
  }

  // primary vertex to be used by this candidate
  AliAODVertex *primVertexAOD  = PrimaryVertex(fourTrackArray,event);
  if(!primVertexAOD) return 0x0;

  Double_t d0z0[2],covd0z0[3];
  postrack1->PropagateToDCA(primVertexAOD,fBzkG,kVeryBig,d0z0,covd0z0);
  d0[0]=d0z0[0];
  d0err[0] = TMath::Sqrt(covd0z0[0]);
  negtrack1->PropagateToDCA(primVertexAOD,fBzkG,kVeryBig,d0z0,covd0z0);
  d0[1]=d0z0[0];
  d0err[1] = TMath::Sqrt(covd0z0[0]);
  postrack2->PropagateToDCA(primVertexAOD,fBzkG,kVeryBig,d0z0,covd0z0);
  d0[2]=d0z0[0];
  d0err[2] = TMath::Sqrt(covd0z0[0]);
  negtrack2->PropagateToDCA(primVertexAOD,fBzkG,kVeryBig,d0z0,covd0z0);
  d0[3]=d0z0[0];
  d0err[3] = TMath::Sqrt(covd0z0[0]);


  // create the object AliAODRecoDecayHF4Prong
  Double_t pos[3]; primVertexAOD->GetXYZ(pos);
  Double_t dca[6]={dcap1n1,0.,dcap1n2,dcap2n1,0.,dcap2n2};
  Double_t dist12=TMath::Sqrt((vertexp1n1->GetX()-pos[0])*(vertexp1n1->GetX()-pos[0])+(vertexp1n1->GetY()-pos[1])*(vertexp1n1->GetY()-pos[1])+(vertexp1n1->GetZ()-pos[2])*(vertexp1n1->GetZ()-pos[2]));
  Double_t dist3=TMath::Sqrt((vertexp1n1p2->GetX()-pos[0])*(vertexp1n1p2->GetX()-pos[0])+(vertexp1n1p2->GetY()-pos[1])*(vertexp1n1p2->GetY()-pos[1])+(vertexp1n1p2->GetZ()-pos[2])*(vertexp1n1p2->GetZ()-pos[2]));
  Double_t dist4=TMath::Sqrt((secVert->GetX()-pos[0])*(secVert->GetX()-pos[0])+(secVert->GetY()-pos[1])*(secVert->GetY()-pos[1])+(secVert->GetZ()-pos[2])*(secVert->GetZ()-pos[2]));
  Short_t charge=0;
  AliAODRecoDecayHF4Prong *the4Prong = new AliAODRecoDecayHF4Prong(secVert,px,py,pz,d0,d0err,dca,dist12,dist3,dist4,charge);
  the4Prong->SetOwnPrimaryVtx(primVertexAOD);
  UShort_t id[4]={(UShort_t)postrack1->GetID(),(UShort_t)negtrack1->GetID(),(UShort_t)postrack2->GetID(),(UShort_t)negtrack2->GetID()};
  the4Prong->SetProngIDs(4,id);

  delete primVertexAOD; primVertexAOD=NULL;

  ok4Prong=(Bool_t)fCutsD0toKpipipi->IsSelected(the4Prong,AliRDHFCuts::kCandidate);


  if(!fRecoPrimVtxSkippingTrks && !fRmTrksFromPrimVtx && !fMixEvent) {
    the4Prong->UnsetOwnPrimaryVtx();
  }

 
  // get PID info from ESD
  Double_t esdpid0[5]={0.,0.,0.,0.,0.};
  if(postrack1->GetStatus()&AliESDtrack::kESDpid) postrack1->GetESDpid(esdpid0);
  Double_t esdpid1[5]={0.,0.,0.,0.,0.};
  if(negtrack1->GetStatus()&AliESDtrack::kESDpid) negtrack1->GetESDpid(esdpid1);
  Double_t esdpid2[5]={0.,0.,0.,0.,0.};
  if(postrack2->GetStatus()&AliESDtrack::kESDpid) postrack2->GetESDpid(esdpid2);
  Double_t esdpid3[5]={0.,0.,0.,0.,0.};
  if(negtrack2->GetStatus()&AliESDtrack::kESDpid) negtrack2->GetESDpid(esdpid3);

  Double_t esdpid[20];
  for(Int_t i=0;i<5;i++) {
    esdpid[i]    = esdpid0[i];
    esdpid[5+i]  = esdpid1[i];
    esdpid[10+i] = esdpid2[i];
    esdpid[15+i] = esdpid3[i];
  }
  the4Prong->SetPID(4,esdpid);
  
  return the4Prong;
}
//-----------------------------------------------------------------------------
AliAODVertex* AliAnalysisVertexingHF::PrimaryVertex(const TObjArray *trkArray,
						    AliVEvent *event) const
{
  // Returns primary vertex to be used for this candidate
  //AliCodeTimerAuto("",0);

  AliESDVertex *vertexESD = 0;
  AliAODVertex *vertexAOD = 0;


  if(!fRecoPrimVtxSkippingTrks && !fRmTrksFromPrimVtx) { 
    // primary vertex from the input event
    
    vertexESD = new AliESDVertex(*fV1);

  } else {
    // primary vertex specific to this candidate

    Int_t nTrks = trkArray->GetEntriesFast();
    AliVertexerTracks *vertexer = new AliVertexerTracks(event->GetMagneticField());

    if(fRecoPrimVtxSkippingTrks) { 
      // recalculating the vertex
      
      if(strstr(fV1->GetTitle(),"VertexerTracksWithConstraint")) {
	Float_t diamondcovxy[3];
	event->GetDiamondCovXY(diamondcovxy);
	Double_t pos[3]={event->GetDiamondX(),event->GetDiamondY(),0.};
	Double_t cov[6]={diamondcovxy[0],diamondcovxy[1],diamondcovxy[2],0.,0.,10.*10.};
	AliESDVertex *diamond = new AliESDVertex(pos,cov,1.,1);
	vertexer->SetVtxStart(diamond);
	delete diamond; diamond=NULL;
	if(strstr(fV1->GetTitle(),"VertexerTracksWithConstraintOnlyFitter")) 
	  vertexer->SetOnlyFitter();
      }
      Int_t skipped[1000];
      Int_t nTrksToSkip=0,id;
      AliExternalTrackParam *t = 0;
      for(Int_t i=0; i<nTrks; i++) {
	t = (AliExternalTrackParam*)trkArray->UncheckedAt(i);
	id = (Int_t)t->GetID();
	if(id<0) continue;
	skipped[nTrksToSkip++] = id;
      }
      // TEMPORARY FIX
      // For AOD, skip also tracks without covariance matrix
      if(fInputAOD) {
	Double_t covtest[21];
	for(Int_t j=0; j<event->GetNumberOfTracks(); j++) {
	  AliVTrack *vtrack = (AliVTrack*)event->GetTrack(j);
	  if(!vtrack->GetCovarianceXYZPxPyPz(covtest)) {
	    id = (Int_t)vtrack->GetID();
	    if(id<0) continue;
	    skipped[nTrksToSkip++] = id;
	  }
	}
      }
      for(Int_t ijk=nTrksToSkip; ijk<1000; ijk++) skipped[ijk]=-1;
      //
      vertexer->SetSkipTracks(nTrksToSkip,skipped);
      vertexESD = (AliESDVertex*)vertexer->FindPrimaryVertex(event); 
      
    } else if(fRmTrksFromPrimVtx && nTrks>0) { 
      // removing the prongs tracks
      
      TObjArray rmArray(nTrks);
      UShort_t *rmId = new UShort_t[nTrks];
      AliESDtrack *esdTrack = 0;
      AliESDtrack *t = 0;
      for(Int_t i=0; i<nTrks; i++) {
	t = (AliESDtrack*)trkArray->UncheckedAt(i);
	esdTrack = new AliESDtrack(*t);
	rmArray.AddLast(esdTrack);
	if(esdTrack->GetID()>=0) {
	  rmId[i]=(UShort_t)esdTrack->GetID();
	} else {
	  rmId[i]=9999;
	}
      }
      Float_t diamondxy[2]={static_cast<Float_t>(event->GetDiamondX()),static_cast<Float_t>(event->GetDiamondY())};
      vertexESD = vertexer->RemoveTracksFromVertex(fV1,&rmArray,rmId,diamondxy);
      delete [] rmId; rmId=NULL;
      rmArray.Delete();
      
    }

    if(!vertexESD) return vertexAOD;
    if(vertexESD->GetNContributors()<=0) { 
      //AliDebug(2,"vertexing failed"); 
      delete vertexESD; vertexESD=NULL;
      return vertexAOD;
    }

    delete vertexer; vertexer=NULL;

  }

  // convert to AliAODVertex
  Double_t pos[3],cov[6],chi2perNDF;
  vertexESD->GetXYZ(pos); // position
  vertexESD->GetCovMatrix(cov); //covariance matrix
  chi2perNDF = vertexESD->GetChi2toNDF();
  delete vertexESD; vertexESD=NULL;

  vertexAOD = new AliAODVertex(pos,cov,chi2perNDF);

  return vertexAOD;
}
//-----------------------------------------------------------------------------
void AliAnalysisVertexingHF::PrintStatus() const {
  // Print parameters being used

  //printf("Preselections:\n");
  //   fTrackFilter->Dump();
  if(fSecVtxWithKF) {
    printf("Secondary vertex with Kalman filter package (AliKFParticle)\n");
  } else {
    printf("Secondary vertex with AliVertexerTracks\n");
  }
  if(fRecoPrimVtxSkippingTrks) printf("RecoPrimVtxSkippingTrks\n");
  if(fRmTrksFromPrimVtx) printf("RmTrksFromPrimVtx\n");
  if(fD0toKpi) {
    printf("Reconstruct D0->Kpi candidates with cuts:\n");
    if(fCutsD0toKpi) fCutsD0toKpi->PrintAll();
  }
  if(fDstar) {
    printf("Reconstruct D*->D0pi candidates with cuts:\n");
    if(fFindVertexForDstar) {
      printf("    Reconstruct a secondary vertex for the D*\n");
    } else {
      printf("    Assume the D* comes from the primary vertex\n");
    }
    if(fCutsDStartoKpipi) fCutsDStartoKpipi->PrintAll();
  }
  if(fJPSItoEle) {
    printf("Reconstruct J/psi from B candidates with cuts:\n");
    if(fCutsJpsitoee) fCutsJpsitoee->PrintAll();
  }
  if(f3Prong) {
    printf("Reconstruct 3 prong candidates.\n");
    printf("  D+->Kpipi cuts:\n");
    if(fCutsDplustoKpipi) fCutsDplustoKpipi->PrintAll();
    printf("  Ds->KKpi cuts:\n");
    if(fCutsDstoKKpi) fCutsDstoKKpi->PrintAll();
    printf("  Lc->pKpi cuts:\n");
    if(fCutsLctopKpi) fCutsLctopKpi->PrintAll();
  }
  if(f4Prong) {
    printf("Reconstruct 4 prong candidates.\n");
    printf("  D0->Kpipipi cuts:\n");
    if(fCutsD0toKpipipi) fCutsD0toKpipipi->PrintAll();
  }
  if(fCascades) {
    printf("Reconstruct cascades candidates formed with v0s.\n");
    printf("  Lc -> k0s P & Lc -> L Pi cuts:\n");
    if(fCutsLctoV0) fCutsLctoV0->PrintAll();
  }

  return;
}
//-----------------------------------------------------------------------------
AliAODVertex* AliAnalysisVertexingHF::ReconstructSecondaryVertex(TObjArray *trkArray,
								 Double_t &dispersion,Bool_t useTRefArray) const
{
  // Secondary vertex reconstruction with AliVertexerTracks or AliKFParticle
  //AliCodeTimerAuto("",0);

  AliESDVertex *vertexESD = 0;
  AliAODVertex *vertexAOD = 0;

  if(!fSecVtxWithKF) { // AliVertexerTracks

    fVertexerTracks->SetVtxStart(fV1);
    vertexESD = (AliESDVertex*)fVertexerTracks->VertexForSelectedESDTracks(trkArray);

    if(!vertexESD) return vertexAOD;

    if(vertexESD->GetNContributors()!=trkArray->GetEntriesFast()) { 
      //AliDebug(2,"vertexing failed"); 
      delete vertexESD; vertexESD=NULL;
      return vertexAOD;
    }
    
    Double_t vertRadius2=vertexESD->GetX()*vertexESD->GetX()+vertexESD->GetY()*vertexESD->GetY();
    if(vertRadius2>8.){
      // vertex outside beam pipe, reject candidate to avoid propagation through material
      delete vertexESD; vertexESD=NULL;
      return vertexAOD;
    }

  } else { // Kalman Filter vertexer (AliKFParticle)

    AliKFParticle::SetField(fBzkG);

    AliKFVertex vertexKF;

    Int_t nTrks = trkArray->GetEntriesFast();
    for(Int_t i=0; i<nTrks; i++) {
      AliESDtrack *esdTrack = (AliESDtrack*)trkArray->At(i);
      AliKFParticle daughterKF(*esdTrack,211);
      vertexKF.AddDaughter(daughterKF);
    }
    vertexESD = new AliESDVertex(vertexKF.Parameters(),
				 vertexKF.CovarianceMatrix(),
				 vertexKF.GetChi2(),
				 vertexKF.GetNContributors());

  }

  // convert to AliAODVertex
  Double_t pos[3],cov[6],chi2perNDF;
  vertexESD->GetXYZ(pos); // position
  vertexESD->GetCovMatrix(cov); //covariance matrix
  chi2perNDF = vertexESD->GetChi2toNDF();
  dispersion = vertexESD->GetDispersion();
  delete vertexESD; vertexESD=NULL;

  Int_t nprongs= (useTRefArray ? 0 : trkArray->GetEntriesFast());
  vertexAOD = new AliAODVertex(pos,cov,chi2perNDF,0x0,-1,AliAODVertex::kUndef,nprongs);

  return vertexAOD;
}
//-----------------------------------------------------------------------------
Bool_t AliAnalysisVertexingHF::SelectInvMassAndPt3prong(TObjArray *trkArray){
  // Invariant mass cut on tracks
  //AliCodeTimerAuto("",0);

  Int_t retval=kFALSE;
  Double_t momentum[3];
  Double_t px[3],py[3],pz[3];
  for(Int_t iTrack=0; iTrack<3; iTrack++){
    AliESDtrack *track = (AliESDtrack*)trkArray->UncheckedAt(iTrack);
    track->GetPxPyPz(momentum);
    px[iTrack] = momentum[0]; py[iTrack] = momentum[1]; pz[iTrack] = momentum[2]; 
  }
  retval = SelectInvMassAndPt3prong(px,py,pz);

  return retval;
}

//-----------------------------------------------------------------------------
Bool_t AliAnalysisVertexingHF::SelectInvMassAndPt4prong(TObjArray *trkArray){
  // Invariant mass cut on tracks
  //AliCodeTimerAuto("",0);

  Int_t retval=kFALSE;
  Double_t momentum[3];
  Double_t px[4],py[4],pz[4];

  for(Int_t iTrack=0; iTrack<4; iTrack++){
    AliESDtrack *track = (AliESDtrack*)trkArray->UncheckedAt(iTrack);
    track->GetPxPyPz(momentum);
    px[iTrack] = momentum[0]; py[iTrack] = momentum[1]; pz[iTrack] = momentum[2]; 
  }

  retval = SelectInvMassAndPt4prong(px,py,pz);

  return retval;
}
//-----------------------------------------------------------------------------
Bool_t AliAnalysisVertexingHF::SelectInvMassAndPtDstarD0pi(TObjArray *trkArray){
  // Invariant mass cut on tracks
  //AliCodeTimerAuto("",0);

  Int_t retval=kFALSE;
  Double_t momentum[3];
  Double_t px[2],py[2],pz[2];

  for(Int_t iTrack=0; iTrack<2; iTrack++){
    AliESDtrack *track = (AliESDtrack*)trkArray->UncheckedAt(iTrack);
    track->GetPxPyPz(momentum);
    px[iTrack] = momentum[0]; py[iTrack] = momentum[1]; pz[iTrack] = momentum[2]; 
  }
  retval = SelectInvMassAndPtDstarD0pi(px,py,pz);

  return retval;
}
//-----------------------------------------------------------------------------
Bool_t AliAnalysisVertexingHF::SelectInvMassAndPtD0Kpi(Double_t *px,
						       Double_t *py,
						       Double_t *pz){
  // Check invariant mass cut and pt candidate cut
  //AliCodeTimerAuto("",0);

  UInt_t pdg2[2];
  Int_t nprongs=2;
  Double_t minv2,mrange;
  Double_t lolim,hilim;
  Double_t minPt=0;
  Bool_t retval=kFALSE;

  fMassCalc2->SetPxPyPzProngs(nprongs,px,py,pz);
  fOKInvMassD0=kFALSE;
  // pt cut
  minPt=fCutsD0toKpi->GetMinPtCandidate();
  if(minPt>0.1) 
    if(fMassCalc2->Pt2() < minPt*minPt) return retval;
  // mass cut
  mrange=fCutsD0toKpi->GetMassCut();
  lolim=fMassDzero-mrange;
  hilim=fMassDzero+mrange;
  pdg2[0]=211; pdg2[1]=321;
  minv2 = fMassCalc2->InvMass2(nprongs,pdg2);
  if(minv2>lolim*lolim && minv2<hilim*hilim ){
    retval=kTRUE;
    fOKInvMassD0=kTRUE;
  }
  pdg2[0]=321; pdg2[1]=211;
  minv2 = fMassCalc2->InvMass2(nprongs,pdg2);
  if(minv2>lolim*lolim && minv2<hilim*hilim ){
    retval=kTRUE;
    fOKInvMassD0=kTRUE;
  }
  return retval;
}

//-----------------------------------------------------------------------------
Bool_t AliAnalysisVertexingHF::SelectInvMassAndPtJpsiee(Double_t *px,
							Double_t *py,
							Double_t *pz){
  // Check invariant mass cut and pt candidate cut
  //AliCodeTimerAuto("",0);

  UInt_t pdg2[2];
  Int_t nprongs=2;
  Double_t minv2,mrange;
  Double_t lolim,hilim;
  Double_t minPt=0;
  Bool_t retval=kFALSE;

  fMassCalc2->SetPxPyPzProngs(nprongs,px,py,pz);
  fOKInvMassJpsi=kFALSE;
  // pt cut
  minPt=fCutsJpsitoee->GetMinPtCandidate();
  if(minPt>0.1) 
    if(fMassCalc2->Pt2() < minPt*minPt) return retval;
  // mass cut
  mrange=fCutsJpsitoee->GetMassCut();
  lolim=fMassJpsi-mrange;
  hilim=fMassJpsi+mrange;

  pdg2[0]=11; pdg2[1]=11;
  minv2 = fMassCalc2->InvMass2(nprongs,pdg2);
  if(minv2>lolim*lolim && minv2<hilim*hilim ){
    retval=kTRUE;
    fOKInvMassJpsi=kTRUE;
  }

  return retval;
}
//-----------------------------------------------------------------------------
Bool_t AliAnalysisVertexingHF::SelectInvMassAndPt3prong(Double_t *px,
							Double_t *py,
							Double_t *pz,
							Int_t pidLcStatus){
  // Check invariant mass cut and pt candidate cut
  //AliCodeTimerAuto("",0);

  UInt_t pdg3[3];
  Int_t nprongs=3;
  Double_t minv2,mrange;
  Double_t lolim,hilim;
  Double_t minPt=0;
  Bool_t retval=kFALSE;


  fMassCalc3->SetPxPyPzProngs(nprongs,px,py,pz);
  fOKInvMassDplus=kFALSE;
  fOKInvMassDs=kFALSE;
  fOKInvMassLc=kFALSE;
  // pt cut
  minPt=TMath::Min(fCutsDplustoKpipi->GetMinPtCandidate(),fCutsDstoKKpi->GetMinPtCandidate());
  minPt=TMath::Min(minPt,fCutsLctopKpi->GetMinPtCandidate());
  if(minPt>0.1) 
    if(fMassCalc3->Pt2() < minPt*minPt) return retval;
  // D+->Kpipi
  mrange=fCutsDplustoKpipi->GetMassCut();
  lolim=fMassDplus-mrange;
  hilim=fMassDplus+mrange;
  pdg3[0]=211; pdg3[1]=321; pdg3[2]=211;
  minv2 = fMassCalc3->InvMass2(nprongs,pdg3);
  if(minv2>lolim*lolim && minv2<hilim*hilim ){
    retval=kTRUE;
    fOKInvMassDplus=kTRUE;
  }
  // Ds+->KKpi
  mrange=fCutsDstoKKpi->GetMassCut();
  lolim=fMassDs-mrange;
  hilim=fMassDs+mrange;
  pdg3[0]=321; pdg3[1]=321; pdg3[2]=211;
  minv2 = fMassCalc3->InvMass2(nprongs,pdg3);
  if(minv2>lolim*lolim && minv2<hilim*hilim ){
    retval=kTRUE;
    fOKInvMassDs=kTRUE;
  }
  pdg3[0]=211; pdg3[1]=321; pdg3[2]=321;
  minv2 = fMassCalc3->InvMass2(nprongs,pdg3);
  if(minv2>lolim*lolim && minv2<hilim*hilim ){
    retval=kTRUE;
    fOKInvMassDs=kTRUE;
  }
  // Lc->pKpi
  mrange=fCutsLctopKpi->GetMassCut();
  lolim=fMassLambdaC-mrange;
  hilim=fMassLambdaC+mrange;
  if(pidLcStatus&1){
    pdg3[0]=2212; pdg3[1]=321; pdg3[2]=211;
    minv2 = fMassCalc3->InvMass2(nprongs,pdg3);
    if(minv2>lolim*lolim && minv2<hilim*hilim ){
      retval=kTRUE;
      fOKInvMassLc=kTRUE;
    }
  }
  if(pidLcStatus&2){
    pdg3[0]=211; pdg3[1]=321; pdg3[2]=2212;
    minv2 = fMassCalc3->InvMass2(nprongs,pdg3);
    if(minv2>lolim*lolim && minv2<hilim*hilim ){
      retval=kTRUE;
      fOKInvMassLc=kTRUE;
    }
  }

  return retval;
}

//-----------------------------------------------------------------------------
Bool_t AliAnalysisVertexingHF::SelectInvMassAndPtDstarD0pi(Double_t *px,
							   Double_t *py,
							   Double_t *pz){
  // Check invariant mass cut and pt candidate cut
  //AliCodeTimerAuto("",0);

  UInt_t pdg2[2];
  Int_t nprongs=2;
  Double_t minv2,mrange;
  Double_t lolim,hilim;
  Double_t minPt=0;
  Bool_t retval=kFALSE;

  fMassCalc2->SetPxPyPzProngs(nprongs,px,py,pz);
  fOKInvMassDstar=kFALSE;
  // pt cut
  minPt=fCutsDStartoKpipi->GetMinPtCandidate();
  if(minPt>0.1) 
    if(fMassCalc2->Pt2() < minPt*minPt) return retval;
  // mass cut
  pdg2[0]=211; pdg2[1]=421; // in twoTrackArrayCasc we put the pion first
  mrange=fCutsDStartoKpipi->GetMassCut();
  lolim=fMassDstar-mrange;
  hilim=fMassDstar+mrange;
  minv2 = fMassCalc2->InvMass2(nprongs,pdg2);
  if(minv2>lolim*lolim && minv2<hilim*hilim ){
    retval=kTRUE;
    fOKInvMassDstar=kTRUE;
  }

  return retval;
}

//-----------------------------------------------------------------------------
Bool_t AliAnalysisVertexingHF::SelectInvMassAndPt4prong(Double_t *px,
							Double_t *py,
							Double_t *pz){
  // Check invariant mass cut and pt candidate cut
  //AliCodeTimerAuto("",0);

  UInt_t pdg4[4];
  Int_t nprongs=4;
  Double_t minv2,mrange;
  Double_t lolim,hilim;
  Double_t minPt=0;
  Bool_t retval=kFALSE;

  // D0->Kpipipi without PID
  fMassCalc4->SetPxPyPzProngs(nprongs,px,py,pz);
  fOKInvMassD0to4p=kFALSE;
  // pt cut
  minPt=fCutsD0toKpipipi->GetMinPtCandidate();
  if(minPt>0.1) 
    if(fMassCalc4->Pt2() < minPt*minPt) return retval;
  // mass cut
  mrange=fCutsD0toKpipipi->GetMassCut();
  lolim=fMassDzero-mrange;
  hilim=fMassDzero+mrange;

  pdg4[0]=321; pdg4[1]=211; pdg4[2]=211; pdg4[3]=211;
  minv2 = fMassCalc4->InvMass2(nprongs,pdg4);
  if(minv2>lolim*lolim && minv2<hilim*hilim ){
    retval=kTRUE;
    fOKInvMassD0to4p=kTRUE;
  }

  pdg4[0]=211; pdg4[1]=321; pdg4[2]=211; pdg4[3]=211;
  minv2 = fMassCalc4->InvMass2(nprongs,pdg4);
  if(minv2>lolim*lolim && minv2<hilim*hilim ){
    retval=kTRUE;
    fOKInvMassD0to4p=kTRUE;
  }

  pdg4[0]=211; pdg4[1]=211; pdg4[2]=321; pdg4[3]=211;
  minv2 = fMassCalc4->InvMass2(nprongs,pdg4);
  if(minv2>lolim*lolim && minv2<hilim*hilim ){
    retval=kTRUE;
    fOKInvMassD0to4p=kTRUE;
  }

  pdg4[0]=211; pdg4[1]=211; pdg4[2]=211; pdg4[3]=321;
  minv2 = fMassCalc4->InvMass2(nprongs,pdg4);
  if(minv2>lolim*lolim && minv2<hilim*hilim ){
    retval=kTRUE;
    fOKInvMassD0to4p=kTRUE;
  }

  return retval;
}
//-----------------------------------------------------------------------------
Bool_t AliAnalysisVertexingHF::SelectInvMassAndPtCascade(Double_t *px,
							 Double_t *py,
							 Double_t *pz){
  // Check invariant mass cut and pt candidate cut
  //AliCodeTimerAuto("",0);

  UInt_t pdg2[2];
  Int_t nprongs=2;
  Double_t minv2,mrange;
  Double_t lolim,hilim;
  //  Double_t minPt=0;
  Bool_t retval=kFALSE;
  
  fMassCalc2->SetPxPyPzProngs(nprongs,px,py,pz);
  //  minPt=fCutsLctoV0->GetMinPtCandidate();
  fOKInvMassLctoV0=kFALSE; 
  mrange=fCutsLctoV0->GetMassCut();
  lolim=fMassLambdaC-mrange;
  hilim=fMassLambdaC+mrange;
  pdg2[0]=2212;pdg2[1]=310;
  minv2=fMassCalc2->InvMass2(2,pdg2);
  if(minv2>lolim*lolim && minv2<hilim*hilim ){
    retval=kTRUE;
    fOKInvMassLctoV0=kTRUE;
  }
  pdg2[0]=211;pdg2[1]=3122;
  minv2=fMassCalc2->InvMass2(2,pdg2);
  if(minv2>lolim*lolim && minv2<hilim*hilim ){
    retval=kTRUE;
    fOKInvMassLctoV0=kTRUE;
  }

  return retval;
}
//-----------------------------------------------------------------------------
void AliAnalysisVertexingHF::SelectTracksAndCopyVertex(const AliVEvent *event,
						       Int_t trkEntries,
						       TObjArray &seleTrksArray,
						       TObjArray &tracksAtVertex,
						       Int_t &nSeleTrks,
						       UChar_t *seleFlags,Int_t *evtNumber)
{
  // Apply single-track preselection.
  // Fill a TObjArray with selected tracks (for displaced vertices or
  // soft pion from D*). Selection flag stored in seleFlags.
  // Create the AliESDVertex object (convert from AliAODVertex if necessary)
  // In case of AOD input, also fill fAODMap for track index<->ID
  //AliCodeTimerAuto("",0);

  const AliVVertex *vprimary = event->GetPrimaryVertex();

  if(fV1) { delete fV1; fV1=NULL; }
  if(fAODMap) { delete [] fAODMap; fAODMap=NULL; }

  Int_t nindices=0;
  UShort_t *indices = 0;
  Double_t pos[3],cov[6];
  const Int_t entries = event->GetNumberOfTracks();
  AliCentrality* cent;
 
  if(!fInputAOD) { // ESD
    fV1 = new AliESDVertex(*((AliESDVertex*)vprimary));
    cent=((AliESDEvent*)event)->GetCentrality();
 } else {         // AOD
    vprimary->GetXYZ(pos);
    vprimary->GetCovarianceMatrix(cov);
    fV1 = new AliESDVertex(pos,cov,100.,100,vprimary->GetName());
    if(entries<=0) return;
    indices = new UShort_t[entries];
    memset(indices,0,sizeof(UShort_t)*entries);
    fAODMapSize = 100000;
    fAODMap = new Int_t[fAODMapSize];
    memset(fAODMap,0,sizeof(Int_t)*fAODMapSize);
    cent=((AliAODEvent*)event)->GetCentrality();
  }
  Float_t centperc=cent->GetCentralityPercentile("V0M");

  Bool_t okDisplaced=kFALSE,okSoftPi=kFALSE,okFor3Prong=kFALSE;
  nSeleTrks=0;
 
  // transfer ITS tracks from event to arrays
  for(Int_t i=0; i<entries; i++) {
    AliVTrack *track;
    track = (AliVTrack*)event->GetTrack(i);

    // skip pure ITS SA tracks
    if(track->GetStatus()&AliESDtrack::kITSpureSA) continue;

    // skip tracks without ITS
    if(!(track->GetStatus()&AliESDtrack::kITSin)) continue;

    // skip tracks with negative ID 
    // (these are duplicated TPC-only AOD tracks, for jet analysis...)
    if(track->GetID()<0) continue;

    // TEMPORARY: check that the cov matrix is there
    Double_t covtest[21];
    if(!track->GetCovarianceXYZPxPyPz(covtest)) continue;
    //

    if(fInputAOD) {
      AliAODTrack *aodt = (AliAODTrack*)track;
      if(aodt->GetUsedForPrimVtxFit()) { 
	indices[nindices]=aodt->GetID(); nindices++; 
      }
      Int_t ind = (Int_t)aodt->GetID();
      if (ind>-1 && ind < fAODMapSize) fAODMap[ind] = i;
    }

    AliESDtrack *esdt = 0;

    if(!fInputAOD) {
      esdt = (AliESDtrack*)track;
    } else {
      esdt = new AliESDtrack(track);
    }

    // single track selection
    okDisplaced=kFALSE; okSoftPi=kFALSE; okFor3Prong=kFALSE;
    if(fMixEvent && i<trkEntries){
      evtNumber[i]=((AliMixedEvent*)event)->EventIndex(i);
      const AliVVertex* eventVtx=((AliMixedEvent*)event)->GetEventVertex(i);
      Double_t vtxPos[3],primPos[3],primCov[6],trasl[3];
      eventVtx->GetXYZ(vtxPos);
      vprimary->GetXYZ(primPos);
      eventVtx->GetCovarianceMatrix(primCov);
      for(Int_t ind=0;ind<3;ind++){
	trasl[ind]=vtxPos[ind]-primPos[ind];
      }
      
      Bool_t isTransl=esdt->Translate(trasl,primCov);
      if(!isTransl) {
	delete esdt;
	esdt = NULL;
	continue;
      }
    }

    if(SingleTrkCuts(esdt,centperc,okDisplaced,okSoftPi,okFor3Prong) && nSeleTrks<trkEntries) {
      esdt->PropagateToDCA(fV1,fBzkG,kVeryBig);
      seleTrksArray.AddLast(esdt);
      tracksAtVertex.AddLast(new AliExternalTrackParam(*esdt));
      seleFlags[nSeleTrks]=0;
      if(okDisplaced) SETBIT(seleFlags[nSeleTrks],kBitDispl);
      if(okFor3Prong)    SETBIT(seleFlags[nSeleTrks],kBit3Prong);
      if(okSoftPi)    SETBIT(seleFlags[nSeleTrks],kBitSoftPi);

      // Check the PID
      SETBIT(seleFlags[nSeleTrks],kBitPionCompat);
      SETBIT(seleFlags[nSeleTrks],kBitKaonCompat);
      SETBIT(seleFlags[nSeleTrks],kBitProtonCompat);
      Bool_t useTPC=kTRUE;
      if(fUseTOFPID){
	Double_t nsigmatofPi= fPidResponse->NumberOfSigmasTOF(esdt,AliPID::kPion);
	if(nsigmatofPi>-990. && (nsigmatofPi<-fnSigmaTOFPionLow || nsigmatofPi>fnSigmaTOFPionHi)){
	  CLRBIT(seleFlags[nSeleTrks],kBitPionCompat);
	}
	Double_t nsigmatofK= fPidResponse->NumberOfSigmasTOF(esdt,AliPID::kKaon);
	if(nsigmatofK>-990. && (nsigmatofK<-fnSigmaTOFKaonLow || nsigmatofK>fnSigmaTOFKaonHi)){
	  CLRBIT(seleFlags[nSeleTrks],kBitKaonCompat);
	}
 	Double_t nsigmatofP= fPidResponse->NumberOfSigmasTOF(esdt,AliPID::kProton);
	if(nsigmatofP>-990. && (nsigmatofP<-fnSigmaTOFProtonLow || nsigmatofP>fnSigmaTOFProtonHi)){
	  CLRBIT(seleFlags[nSeleTrks],kBitProtonCompat);
	}
	if(fUseTPCPIDOnlyIfNoTOF && nsigmatofPi>-990.) useTPC=kFALSE;
      }
      if(useTPC && fUseTPCPID && esdt->P()<fMaxMomForTPCPid){ 
	Double_t nsigmatpcPi= fPidResponse->NumberOfSigmasTPC(esdt,AliPID::kPion);
	if(nsigmatpcPi>-990. && (nsigmatpcPi<-fnSigmaTPCPionLow || nsigmatpcPi>fnSigmaTPCPionHi)){
	  CLRBIT(seleFlags[nSeleTrks],kBitPionCompat);
	}
	Double_t nsigmatpcK= fPidResponse->NumberOfSigmasTPC(esdt,AliPID::kKaon);
	if(nsigmatpcK>-990. && (nsigmatpcK<-fnSigmaTPCKaonLow || nsigmatpcK>fnSigmaTPCKaonHi)){
	  CLRBIT(seleFlags[nSeleTrks],kBitKaonCompat);
	}
 	Double_t nsigmatpcP= fPidResponse->NumberOfSigmasTPC(esdt,AliPID::kProton);
	if(nsigmatpcP>-990. && (nsigmatpcP<-fnSigmaTPCProtonLow || nsigmatpcP>fnSigmaTPCProtonHi)){
	  CLRBIT(seleFlags[nSeleTrks],kBitProtonCompat);
	}
      }
      nSeleTrks++;
    } else {
      if(fInputAOD) delete esdt; 
      esdt = NULL;
      continue;
    } 

  } // end loop on tracks

  // primary vertex from AOD
  if(fInputAOD) {
    delete fV1; fV1=NULL;
    vprimary->GetXYZ(pos);
    vprimary->GetCovarianceMatrix(cov);
    Double_t chi2toNDF = vprimary->GetChi2perNDF();
    Int_t ncontr=nindices;
    if(!strcmp(vprimary->GetTitle(),"VertexerTracksWithContraint")) ncontr += 1;
    Double_t chi2=chi2toNDF*(2.*(Double_t)ncontr-3.); 
    fV1 = new AliESDVertex(pos,cov,chi2,ncontr,vprimary->GetName());
    fV1->SetTitle(vprimary->GetTitle());
    fV1->SetIndices(nindices,indices);
  }
  if(indices) { delete [] indices; indices=NULL; }


  return;
}
//-----------------------------------------------------------------------------
void AliAnalysisVertexingHF::SetSelectionBitForPID(AliRDHFCuts *cuts,AliAODRecoDecayHF *rd,Int_t bit) {
  //
  // Set the selection bit for PID
  //
  //AliCodeTimerAuto("",0);
  if(cuts->GetPidHF()) {
    Bool_t usepid=cuts->GetIsUsePID();
    cuts->SetUsePID(kTRUE);
    if(cuts->IsSelectedPID(rd))
      rd->SetSelectionBit(bit);
    cuts->SetUsePID(usepid);
  }
  return;
}
//-----------------------------------------------------------------------------
Bool_t AliAnalysisVertexingHF::SingleTrkCuts(AliESDtrack *trk, 
					     Float_t centralityperc,
					     Bool_t &okDisplaced,
					     Bool_t &okSoftPi,
					     Bool_t &okFor3Prong) const 
{
  // Check if track passes some kinematical cuts  

  // this is needed to store the impact parameters
  //AliCodeTimerAuto("",0);

  trk->RelateToVertex(fV1,fBzkG,kVeryBig);

  UInt_t selectInfo;
  //
  // Track selection, displaced tracks -- 2 prong
  selectInfo = 0; 
  if(centralityperc>=0 && fMaxCentPercentileForTightCuts>=0 
     && fTrackFilter2prongCentral && centralityperc<fMaxCentPercentileForTightCuts){
    // central PbPb events, tighter cuts
    selectInfo = fTrackFilter2prongCentral->IsSelected(trk);
  }else{
    // standard cuts
    if(fTrackFilter) {
      selectInfo = fTrackFilter->IsSelected(trk);
    }
  }
  if(selectInfo) okDisplaced=kTRUE;

  // Track selection, displaced tracks -- 3 prong
  selectInfo = 0; 
  if(centralityperc>=0 && fMaxCentPercentileForTightCuts>=0 
     && fTrackFilter3prongCentral && centralityperc<fMaxCentPercentileForTightCuts){
    // central PbPb events, tighter cuts
    selectInfo = fTrackFilter3prongCentral->IsSelected(trk);
  }else{
    // standard cuts
    if(fTrackFilter) {
      selectInfo = fTrackFilter->IsSelected(trk);
    }
  }
  if(selectInfo) okFor3Prong=kTRUE;

  // Track selection, soft pions
  selectInfo = 0; 
  if(fDstar && fTrackFilterSoftPi) {
    selectInfo = fTrackFilterSoftPi->IsSelected(trk);
  }
  if(selectInfo) okSoftPi=kTRUE;

  if(okDisplaced || okSoftPi || okFor3Prong) return kTRUE;

  return kFALSE;
}


//-----------------------------------------------------------------------------
AliAODv0* AliAnalysisVertexingHF::TransformESDv0toAODv0(AliESDv0 *esdV0, TObjArray *twoTrackArrayV0){
  //
  // Transform ESDv0 to AODv0
  //
  //  this function takes the ESDv0 vertex, computes the DCA variables from the ESDv0
  //  and creates an AODv0 out of them
  //
  //AliCodeTimerAuto("",0);
  Double_t vertex[3]; esdV0->GetXYZ(vertex[0],vertex[1],vertex[2]);
  AliAODVertex *vertexV0 = new AliAODVertex(vertex,esdV0->GetChi2V0(),AliAODVertex::kV0,2);

  // create the v0 neutral track to compute the DCA to the primary vertex
  Double_t xyz[3], pxpypz[3];
  esdV0->XvYvZv(xyz);
  esdV0->PxPyPz(pxpypz);
  Double_t cv[21]; for(int i=0; i<21; i++) cv[i]=0;
  AliNeutralTrackParam *trackesdV0 = new AliNeutralTrackParam(xyz,pxpypz,cv,0);
  if(!trackesdV0) {
    delete vertexV0;
    return 0;
  }
  Double_t d0z0[2],covd0z0[3];
  AliAODVertex *primVertexAOD = PrimaryVertex(); 
  trackesdV0->PropagateToDCA(primVertexAOD,fBzkG,kVeryBig,d0z0,covd0z0);
  Double_t dcaV0ToPrimVertex = TMath::Sqrt(covd0z0[0]);
  // get the v0 daughters to compute their DCA to the v0 vertex and get their momentum
  Double_t dcaV0DaughterToPrimVertex[2];  
  AliExternalTrackParam *posV0track = (AliExternalTrackParam*)twoTrackArrayV0->UncheckedAt(0);
  AliExternalTrackParam *negV0track = (AliExternalTrackParam*)twoTrackArrayV0->UncheckedAt(1);
  if( !posV0track || !negV0track) {
    if(trackesdV0) {delete trackesdV0; trackesdV0=NULL;}
    delete vertexV0;
    delete primVertexAOD;
    return 0;
  }
  posV0track->PropagateToDCA(primVertexAOD,fBzkG,kVeryBig,d0z0,covd0z0);
  //  if ( covd0z0[0]<=0.) dcaV0DaughterToPrimVertex[0] = 0;
  //  else 
  dcaV0DaughterToPrimVertex[0] = TMath::Sqrt(covd0z0[0]);
  negV0track->PropagateToDCA(primVertexAOD,fBzkG,kVeryBig,d0z0,covd0z0);  
  //  if ( covd0z0[0]<=0.)dcaV0DaughterToPrimVertex[1] = 0;
  //  else 
  dcaV0DaughterToPrimVertex[1] = TMath::Sqrt(covd0z0[0]);
  Double_t dcaV0Daughters = esdV0->GetDcaV0Daughters();
  Double_t pmom[3],nmom[3];
  esdV0->GetNPxPyPz(nmom[0],nmom[1],nmom[2]);
  esdV0->GetPPxPyPz(pmom[0],pmom[1],pmom[2]);

  AliAODv0 *aodV0 = new AliAODv0(vertexV0,dcaV0Daughters,dcaV0ToPrimVertex,pmom,nmom,dcaV0DaughterToPrimVertex);
  aodV0->SetOnFlyStatus(esdV0->GetOnFlyStatus());

  delete trackesdV0;
  delete primVertexAOD;

  return aodV0;
}
//-----------------------------------------------------------------------------
void AliAnalysisVertexingHF::SetParametersAtVertex(AliESDtrack* esdt, const AliExternalTrackParam* extpar) const{
  // Set the stored track parameters at primary vertex into AliESDtrack
  //AliCodeTimerAuto("",0);

  const Double_t *par=extpar->GetParameter();
  const Double_t *cov=extpar->GetCovariance();
  Double_t alpha=extpar->GetAlpha();
  Double_t x=extpar->GetX();
  esdt->Set(x,alpha,par,cov);
  return;
}
//-----------------------------------------------------------------------------
void AliAnalysisVertexingHF::SetMasses(){
  // Set the hadron mass values from TDatabasePDG 

  fMassDzero=TDatabasePDG::Instance()->GetParticle(421)->Mass();
  fMassDplus=TDatabasePDG::Instance()->GetParticle(411)->Mass();
  fMassDs=TDatabasePDG::Instance()->GetParticle(431)->Mass();
  fMassLambdaC=TDatabasePDG::Instance()->GetParticle(4122)->Mass();
  fMassDstar=TDatabasePDG::Instance()->GetParticle(413)->Mass();
  fMassJpsi=TDatabasePDG::Instance()->GetParticle(443)->Mass();
}
//-----------------------------------------------------------------------------
Bool_t AliAnalysisVertexingHF::CheckCutsConsistency(){
  //
  // Check the Vertexer and the analysts task consitstecny
  //


  //___ Check if the V0 type from AliRDHFCutsLctoV0 is the same as the one set in the ConfigVertexingHF.C for AliAnalysisVertexingHF


  if ( fCutsLctoV0 && fV0TypeForCascadeVertex != fCutsLctoV0->GetV0Type())
  {
    printf("ERROR: V0 type doesn not match in AliAnalysisVertexingHF (%d) required in AliRDHFCutsLctoV0 (%d)\n",fV0TypeForCascadeVertex,fCutsLctoV0->GetV0Type());
    return kFALSE;
  }
  return kTRUE;
}
//-----------------------------------------------------------------------------

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