ROOT logo
#include "AliAnalysisTaskVnV0.h"

// ROOT includes
#include <TMath.h>

// AliRoot includes
#include "AliInputEventHandler.h"
#include "AliAODEvent.h"
#include "AliAODVertex.h"
#include "AliAODTrack.h"
#include "AliCentrality.h"
#include "AliVHeader.h"
#include "AliAODVZERO.h"
#include "TFile.h"
#include "AliOADBContainer.h"
#include "TH2F.h"
#include "TF1.h"
#include "AliGenHijingEventHeader.h"
#include "AliMCEvent.h"
#include "AliAODMCHeader.h"
#include "AliAODMCParticle.h"
#include "TChain.h"
#include "AliESDtrackCuts.h"
#include "AliESDVertex.h"
#include "AliEventplane.h"
#include "TProfile2D.h"

// STL includes
//#include <iostream>
//using namespace std;

ClassImp(AliAnalysisTaskVnV0)
Bool_t AliAnalysisTaskVnV0::fgIsPsiComputed = kFALSE;
Float_t AliAnalysisTaskVnV0::fgPsi2v0a=999.;
Float_t AliAnalysisTaskVnV0::fgPsi2v0c=999.;
Float_t AliAnalysisTaskVnV0::fgPsi2tpc=999.;
Float_t AliAnalysisTaskVnV0::fgPsi3v0a=999.;
Float_t AliAnalysisTaskVnV0::fgPsi3v0c=999.;
Float_t AliAnalysisTaskVnV0::fgPsi3tpc=999.;
Float_t AliAnalysisTaskVnV0::fgPsi2v0aMC=999.;
Float_t AliAnalysisTaskVnV0::fgPsi2v0cMC=999.;
Float_t AliAnalysisTaskVnV0::fgPsi2tpcMC=999.;
Float_t AliAnalysisTaskVnV0::fgPsi3v0aMC=999.;
Float_t AliAnalysisTaskVnV0::fgPsi3v0cMC=999.;
Float_t AliAnalysisTaskVnV0::fgPsi3tpcMC=999.;

//_____________________________________________________________________________
AliAnalysisTaskVnV0::AliAnalysisTaskVnV0():
  AliAnalysisTaskSE(),
  fVtxCut(10.0),  // cut on |vertex| < fVtxCut
  fEtaCut(0.8),   // cut on |eta| < fEtaCut
  fMinPt(0.15),   // cut on pt > fMinPt
  fMinDistV0(0),
  fMaxDistV0(100),
  fV2(kTRUE),
  fV3(kTRUE),
  fIsMC(kFALSE),
  fQAsw(kFALSE),
  fIsAfter2011(kFALSE),
  fRun(-1),
  fNcluster(70),
  fList(new TList()),
  fList2(new TList()),
  fList3(new TList()),
  fList4(new TList()),
  fMultV0(NULL),
  fV0Cpol(100),
  fV0Apol(100),
  fHResTPCv0A2(NULL),
  fHResTPCv0C2(NULL),
  fHResv0Cv0A2(NULL),
  fHResTPCv0A3(NULL),
  fHResTPCv0C3(NULL),
  fHResv0Cv0A3(NULL),
  fPhiRPv0A(NULL),
  fPhiRPv0C(NULL),
  fPhiRPv0Av3(NULL),
  fPhiRPv0Cv3(NULL),
  fQA(NULL),
  fQA2(NULL),
  fQAv3(NULL),
  fQA2v3(NULL),
  fPID(new AliFlowBayesianPID()),
  fTree(NULL),
  fCentrality(-1),
  evPlAngV0ACor2(0),
  evPlAngV0CCor2(0),
  evPlAng2(0),
  evPlAngV0ACor3(0),
  evPlAngV0CCor3(0),
  evPlAng3(0),
  fContAllChargesV0A(NULL),
  fContAllChargesV0C(NULL),
  fContAllChargesV0Av3(NULL),
  fContAllChargesV0Cv3(NULL),
  fContAllChargesMC(NULL),
  fHResMA2(NULL),
  fHResMC2(NULL),
  fHResAC2(NULL),
  fHResMA3(NULL),
  fHResMC3(NULL),
  fHResAC3(NULL),  
  fContAllChargesMCA(NULL),
  fContAllChargesMCC(NULL),
  fContAllChargesMCAv3(NULL),
  fContAllChargesMCCv3(NULL),
  fFillDCA(kFALSE),
  fContQApid(NULL),
  fModulationDEDx(kFALSE),
  fZvtx(0.),
  fNK0s(0),
  fNpiPos(0),
  fNpiNeg(0),
  fHKsPhi(NULL),
  fHKsPhiEP(NULL),
  fHK0sMass(NULL),
  fHK0sMass2(NULL),
  fHK0vsLambda(NULL),
  fHctauPtEP(NULL),
  fHctauAt1EP(NULL),
  fCutsDaughter(NULL)
{
  // Default constructor (should not be used)
  fList->SetName("resultsV2");
  fList2->SetName("resultsV3");
  fList3->SetName("resultsMC");
  fList4->SetName("QA");

  fList->SetOwner(kTRUE); 
  fList2->SetOwner(kTRUE); 
  fList3->SetOwner(kTRUE); 
  fList4->SetOwner(kTRUE); 

  fPID->SetNewTrackParam(); // Better tuning for TOF PID tracking effect in LHC10h

  for(Int_t i=0;i < 1000;i++){
    fPhiK0s[i] = 0.0;
    fPtK0s[i] = 0.0;
    fIPiPos[i] = 0;
    fIPiNeg[i] = 0;
  }
}

//______________________________________________________________________________
AliAnalysisTaskVnV0::AliAnalysisTaskVnV0(const char *name):
  AliAnalysisTaskSE(name),
  fVtxCut(10.0),  // cut on |vertex| < fVtxCut
  fEtaCut(0.8),   // cut on |eta| < fEtaCut
  fMinPt(0.15),   // cut on pt > fMinPt
  fMinDistV0(0),
  fMaxDistV0(100),
  fV2(kTRUE),
  fV3(kTRUE),
  fIsMC(kFALSE),
  fQAsw(kFALSE),
  fIsAfter2011(kFALSE),
  fRun(-1),
  fNcluster(70),
  fList(new TList()),
  fList2(new TList()),
  fList3(new TList()),
  fList4(new TList()),
  fMultV0(NULL),
  fV0Cpol(100),
  fV0Apol(100),
  fHResTPCv0A2(NULL),
  fHResTPCv0C2(NULL),
  fHResv0Cv0A2(NULL),
  fHResTPCv0A3(NULL),
  fHResTPCv0C3(NULL),
  fHResv0Cv0A3(NULL),
  fPhiRPv0A(NULL),
  fPhiRPv0C(NULL),
  fPhiRPv0Av3(NULL),
  fPhiRPv0Cv3(NULL),
  fQA(NULL),
  fQA2(NULL),
  fQAv3(NULL),
  fQA2v3(NULL),
  fPID(new AliFlowBayesianPID()),
  fTree(NULL),
  fCentrality(-1),
  evPlAngV0ACor2(0),
  evPlAngV0CCor2(0),
  evPlAng2(0),
  evPlAngV0ACor3(0),
  evPlAngV0CCor3(0),
  evPlAng3(0),
  fContAllChargesV0A(NULL),
  fContAllChargesV0C(NULL),
  fContAllChargesV0Av3(NULL),
  fContAllChargesV0Cv3(NULL),
  fContAllChargesMC(NULL),
  fHResMA2(NULL),
  fHResMC2(NULL),
  fHResAC2(NULL),
  fHResMA3(NULL),
  fHResMC3(NULL),
  fHResAC3(NULL),  
  fContAllChargesMCA(NULL),
  fContAllChargesMCC(NULL),
  fContAllChargesMCAv3(NULL),
  fContAllChargesMCCv3(NULL),
  fFillDCA(kFALSE),
  fContQApid(NULL),
  fModulationDEDx(kFALSE),
  fZvtx(0.),
  fNK0s(0),
  fNpiPos(0),
  fNpiNeg(0),
  fHKsPhi(NULL),
  fHKsPhiEP(NULL),
  fHK0sMass(NULL),
  fHK0sMass2(NULL),
  fHK0vsLambda(NULL),
  fHctauPtEP(NULL),
  fHctauAt1EP(NULL),
  fCutsDaughter(NULL)
{

  DefineOutput(1, TList::Class());
  DefineOutput(2, TList::Class());
  DefineOutput(3, TList::Class());
  DefineOutput(4, TList::Class());

  // Output slot #1 writes into a TTree
  fList->SetName("resultsV2");
  fList2->SetName("resultsV3");
  fList3->SetName("resultsMC");
  fList4->SetName("QA");

  fList->SetOwner(kTRUE); 
  fList2->SetOwner(kTRUE); 
  fList3->SetOwner(kTRUE); 
  fList4->SetOwner(kTRUE); 

  fPID->SetNewTrackParam(); // Better tuning for TOF PID tracking effect in LHC10h

  for(Int_t i=0;i < 1000;i++){
    fPhiK0s[i] = 0.0;
    fPtK0s[i] = 0.0;
    fIPiPos[i] = 0;
    fIPiNeg[i] = 0;
  }
}
//_____________________________________________________________________________
AliAnalysisTaskVnV0::~AliAnalysisTaskVnV0()
{

}

//______________________________________________________________________________
void AliAnalysisTaskVnV0::UserCreateOutputObjects()
{

  if(fIsMC) fPID->SetMC(kTRUE);


  // Tree for EP debug (comment the adding to v2 list id not needed)
  fTree = new TTree("tree","tree");
  fTree->Branch("evPlAngV0ACor2",&evPlAngV0ACor2,"evPlAngV0ACor2/F");
  fTree->Branch("evPlAngV0CCor2",&evPlAngV0CCor2,"evPlAngV0CCor2/F");
  fTree->Branch("evPlAng2",&evPlAng2,"evPlAng2/F"); 
  fTree->Branch("fCentrality",&fCentrality,"fCentrality/F"); 
  fTree->Branch("evPlAngV0ACor3",&evPlAngV0ACor3,"evPlAngV0ACor3/F");
  fTree->Branch("evPlAngV0CCor3",&evPlAngV0CCor3,"evPlAngV0CCor3/F");
  fTree->Branch("evPlAng3",&evPlAng3,"evPlAng3/F"); 
  

  // Container analyses (different steps mean different species)
  const Int_t nPtBinsTOF = 45;
  Double_t binsPtTOF[nPtBinsTOF+1] = {0., 0.05,  0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0, 2.25, 2.5, 2.75,3.0,3.25,3.5,3.75,4.0,4.5,5,5.5,6,6.5,7,8,9,10,12,15,20};
  const Int_t nCentrTOF = nCentrBin;
  const Int_t nPsiTOF = 10;  
  const Int_t nChargeBinsTOFres = 2; 
  const Int_t nCentrTOFres = nCentrBin;
  const Int_t nProbTOFres = 4;
  const Int_t nPsiTOFres = 10;
  const Int_t nMaskPID = 3;

  Int_t nDCABin = 1; // put to 1 not to store this info
  if(fFillDCA) nDCABin = 3;
  if(fIsMC && nDCABin>1)  nDCABin = 6;
  /*
    0 = DCAxy < 2.4 && all (or Physical primary if MC)
    1 = DCAxy > 2.4 && all (or Physical primary if MC)
    2 = DCAxy < 2.4 && not Physical Primary for MC
    3 = DCAxy > 2.4 && not Physical Primary for MC
  */
  
  Int_t binsTOF[6] = {nCentrTOFres,nChargeBinsTOFres,nProbTOFres,nPsiTOFres,nMaskPID,nDCABin};
  Int_t binsTOFmc[5] = {nCentrTOFres,nChargeBinsTOFres,1,nPsiTOFres,2};
  Int_t binsTOFmcPureMC[5] = {nCentrTOFres,nChargeBinsTOFres,1,nPsiTOFres,1};

  // v2 container
  fContAllChargesV0A = new AliFlowVZEROResults("v2A",6,binsTOF);
  fContAllChargesV0A->SetVarRange(0,-0.5,nCentrBin-0.5); // centrality
  fContAllChargesV0A->SetVarRange(1,-1.5,1.5);  // charge
  fContAllChargesV0A->SetVarRange(2,0.6,1.0001);// prob
  fContAllChargesV0A->SetVarRange(3,-TMath::Pi()/2,TMath::Pi()/2); // Psi
  fContAllChargesV0A->SetVarRange(4,-0.5,2.5); // pid mask
  fContAllChargesV0A->SetVarRange(5,-0.5,nDCABin-0.5); // DCA mask
  fContAllChargesV0A->SetVarName(0,"centrality");
  fContAllChargesV0A->SetVarName(1,"charge");
  fContAllChargesV0A->SetVarName(2,"prob");
  fContAllChargesV0A->SetVarName(3,"#Psi");
  fContAllChargesV0A->SetVarName(4,"PIDmask");
  fContAllChargesV0A->SetVarName(5,"DCAbin");
  if(fV2) fContAllChargesV0A->AddSpecies("all",nPtBinsTOF,binsPtTOF);
  if(fV2) fContAllChargesV0A->AddSpecies("pi",nPtBinsTOF,binsPtTOF);
  if(fV2) fContAllChargesV0A->AddSpecies("k",nPtBinsTOF,binsPtTOF);
  if(fV2) fContAllChargesV0A->AddSpecies("pr",nPtBinsTOF,binsPtTOF);
  if(fV2) fContAllChargesV0A->AddSpecies("e",nPtBinsTOF,binsPtTOF);
  if(fV2) fContAllChargesV0A->AddSpecies("d",nPtBinsTOF,binsPtTOF);
  if(fV2) fContAllChargesV0A->AddSpecies("t",nPtBinsTOF,binsPtTOF);
  if(fV2) fContAllChargesV0A->AddSpecies("he3",nPtBinsTOF,binsPtTOF);
  if(fV2) fContAllChargesV0A->AddSpecies("mu",nPtBinsTOF,binsPtTOF);
  if(fV2) fContAllChargesV0A->AddSpecies("Ks",nPtBinsTOF,binsPtTOF);
  if(fV2) fContAllChargesV0A->AddSpecies("Lambda",nPtBinsTOF,binsPtTOF);
  if(fV2) fContAllChargesV0A->AddSpecies("pFromLambda",nPtBinsTOF,binsPtTOF);
  if(fV2) fContAllChargesV0A->AddSpecies("piFromK",nPtBinsTOF,binsPtTOF);

  fContAllChargesV0C = new AliFlowVZEROResults("v2C",6,binsTOF);
  fContAllChargesV0C->SetVarRange(0,-0.5,nCentrBin-0.5); // centrality
  fContAllChargesV0C->SetVarRange(1,-1.5,1.5);  // charge
  fContAllChargesV0C->SetVarRange(2,0.6,1.0001);// prob
  fContAllChargesV0C->SetVarRange(3,-TMath::Pi()/2,TMath::Pi()/2); // Psi
  fContAllChargesV0C->SetVarRange(4,-0.5,2.5); // pid mask
  fContAllChargesV0C->SetVarRange(5,-0.5,nDCABin-0.5); // DCA mask
  fContAllChargesV0C->SetVarName(0,"centrality");
  fContAllChargesV0C->SetVarName(1,"charge");
  fContAllChargesV0C->SetVarName(2,"prob");
  fContAllChargesV0C->SetVarName(3,"#Psi");
  fContAllChargesV0C->SetVarName(4,"PIDmask");
  fContAllChargesV0C->SetVarName(5,"DCAbin");
  if(fV2) fContAllChargesV0C->AddSpecies("all",nPtBinsTOF,binsPtTOF);
  if(fV2) fContAllChargesV0C->AddSpecies("pi",nPtBinsTOF,binsPtTOF);
  if(fV2) fContAllChargesV0C->AddSpecies("k",nPtBinsTOF,binsPtTOF);
  if(fV2) fContAllChargesV0C->AddSpecies("pr",nPtBinsTOF,binsPtTOF);
  if(fV2) fContAllChargesV0C->AddSpecies("e",nPtBinsTOF,binsPtTOF);
  if(fV2) fContAllChargesV0C->AddSpecies("d",nPtBinsTOF,binsPtTOF);
  if(fV2) fContAllChargesV0C->AddSpecies("t",nPtBinsTOF,binsPtTOF);
  if(fV2) fContAllChargesV0C->AddSpecies("he3",nPtBinsTOF,binsPtTOF);
  if(fV2) fContAllChargesV0C->AddSpecies("mu",nPtBinsTOF,binsPtTOF);
  if(fV2) fContAllChargesV0C->AddSpecies("Ks",nPtBinsTOF,binsPtTOF);
  if(fV2) fContAllChargesV0C->AddSpecies("Lambda",nPtBinsTOF,binsPtTOF);
  if(fV2) fContAllChargesV0C->AddSpecies("pFromLambda",nPtBinsTOF,binsPtTOF);
  if(fV2) fContAllChargesV0C->AddSpecies("piFromK",nPtBinsTOF,binsPtTOF);

  fList->Add(fContAllChargesV0A);
  fList->Add(fContAllChargesV0C);

  fHctauPtEP = new TProfile2D("hctauPtEP","K^{0}_{s} decay length;p_{T} (GeV/#it{c});#Delta#phi (rad)",40,0,5,10,-TMath::Pi(),TMath::Pi());
  fHctauAt1EP = new TH2F("hctauAt1EP","K^{0}_{s} decay length at 1 GeV/#it{c};c#tau (cm);#Delta#phi (rad)",50,0,50,10,-TMath::Pi(),TMath::Pi());
  // added at the end

  if(fIsMC && fV2){
    fContAllChargesMC = new AliFlowVZEROResults("v2mc",5,binsTOFmc);
    fContAllChargesMC->SetVarRange(0,-0.5,nCentrBin-0.5); // centrality
    fContAllChargesMC->SetVarRange(1,-1.5,1.5);  // charge
    fContAllChargesMC->SetVarRange(2,0.6,1.0001);// prob
    fContAllChargesMC->SetVarRange(3,-TMath::Pi()/2,TMath::Pi()/2); // Psi
    fContAllChargesMC->SetVarRange(4,-0.5,1.5); // pid mask
    fContAllChargesMC->SetVarName(0,"centrality");
    fContAllChargesMC->SetVarName(1,"charge");
    fContAllChargesMC->SetVarName(2,"prob");
    fContAllChargesMC->SetVarName(3,"#Psi");
    fContAllChargesMC->SetVarName(4,"PIDmask");
    fContAllChargesMC->AddSpecies("all",nPtBinsTOF,binsPtTOF);
    fContAllChargesMC->AddSpecies("pi",nPtBinsTOF,binsPtTOF);
    fContAllChargesMC->AddSpecies("k",nPtBinsTOF,binsPtTOF);
    fContAllChargesMC->AddSpecies("pr",nPtBinsTOF,binsPtTOF);
    fContAllChargesMC->AddSpecies("e",nPtBinsTOF,binsPtTOF);
    fContAllChargesMC->AddSpecies("mu",nPtBinsTOF,binsPtTOF);
    fList3->Add(fContAllChargesMC); 

    fContAllChargesMCA = new AliFlowVZEROResults("v2mcA",5,binsTOFmcPureMC);
    fContAllChargesMCA->SetVarRange(0,-0.5,nCentrBin-0.5); // centrality
    fContAllChargesMCA->SetVarRange(1,-1.5,1.5);  // charge
    fContAllChargesMCA->SetVarRange(2,0.6,1.0001);// prob
    fContAllChargesMCA->SetVarRange(3,-TMath::Pi()/2,TMath::Pi()/2); // Psi
    fContAllChargesMCA->SetVarRange(4,-0.5,1.5); // pid mask
    fContAllChargesMCA->SetVarName(0,"centrality");
    fContAllChargesMCA->SetVarName(1,"charge");
    fContAllChargesMCA->SetVarName(2,"prob");
    fContAllChargesMCA->SetVarName(3,"#Psi");
    fContAllChargesMCA->SetVarName(4,"PIDmask");
    fContAllChargesMCA->AddSpecies("all",nPtBinsTOF,binsPtTOF);
    fContAllChargesMCA->AddSpecies("pi",nPtBinsTOF,binsPtTOF);
    fContAllChargesMCA->AddSpecies("k",nPtBinsTOF,binsPtTOF);
    fContAllChargesMCA->AddSpecies("pr",nPtBinsTOF,binsPtTOF);
    fContAllChargesMCA->AddSpecies("e",nPtBinsTOF,binsPtTOF);
    fContAllChargesMCA->AddSpecies("mu",nPtBinsTOF,binsPtTOF);
    fList3->Add(fContAllChargesMCA); 

    fContAllChargesMCC = new AliFlowVZEROResults("v2mcC",5,binsTOFmcPureMC);
    fContAllChargesMCC->SetVarRange(0,-0.5,nCentrBin-0.5); // centrality
    fContAllChargesMCC->SetVarRange(1,-1.5,1.5);  // charge
    fContAllChargesMCC->SetVarRange(2,0.6,1.0001);// prob
    fContAllChargesMCC->SetVarRange(3,-TMath::Pi()/2,TMath::Pi()/2); // Psi
    fContAllChargesMCC->SetVarRange(4,-0.5,1.5); // pid mask
    fContAllChargesMCC->SetVarName(0,"centrality");
    fContAllChargesMCC->SetVarName(1,"charge");
    fContAllChargesMCC->SetVarName(2,"prob");
    fContAllChargesMCC->SetVarName(3,"#Psi");
    fContAllChargesMCC->SetVarName(4,"PIDmask");
    fContAllChargesMCC->AddSpecies("all",nPtBinsTOF,binsPtTOF);
    fContAllChargesMCC->AddSpecies("pi",nPtBinsTOF,binsPtTOF);
    fContAllChargesMCC->AddSpecies("k",nPtBinsTOF,binsPtTOF);
    fContAllChargesMCC->AddSpecies("pr",nPtBinsTOF,binsPtTOF);
    fContAllChargesMCC->AddSpecies("e",nPtBinsTOF,binsPtTOF);
    fContAllChargesMCC->AddSpecies("mu",nPtBinsTOF,binsPtTOF);
    fList3->Add(fContAllChargesMCC); 
  }

  // v3 container
  fContAllChargesV0Av3 = new AliFlowVZEROResults("v3A",6,binsTOF);
  fContAllChargesV0Av3->SetVarRange(0,-0.5,nCentrBin-0.5); // centrality
  fContAllChargesV0Av3->SetVarRange(1,-1.5,1.5);  // charge
  fContAllChargesV0Av3->SetVarRange(2,0.6,1.0001);// prob
  fContAllChargesV0Av3->SetVarRange(3,-TMath::Pi()/3,TMath::Pi()/3); // Psi
  fContAllChargesV0Av3->SetVarRange(5,-0.5,nDCABin-0.5); // DCA mask
  fContAllChargesV0Av3->SetVarRange(4,-0.5,2.5); // pid mask
  fContAllChargesV0Av3->SetVarName(0,"centrality");
  fContAllChargesV0Av3->SetVarName(1,"charge");
  fContAllChargesV0Av3->SetVarName(2,"prob");
  fContAllChargesV0Av3->SetVarName(3,"#Psi");
  fContAllChargesV0Av3->SetVarName(4,"PIDmask");
  fContAllChargesV0Av3->SetVarName(5,"DCAbin");
  if(fV3) fContAllChargesV0Av3->AddSpecies("all",nPtBinsTOF,binsPtTOF);
  if(fV3) fContAllChargesV0Av3->AddSpecies("pi",nPtBinsTOF,binsPtTOF);
  if(fV3) fContAllChargesV0Av3->AddSpecies("k",nPtBinsTOF,binsPtTOF);
  if(fV3) fContAllChargesV0Av3->AddSpecies("pr",nPtBinsTOF,binsPtTOF);
  if(fV3) fContAllChargesV0Av3->AddSpecies("e",nPtBinsTOF,binsPtTOF);
  if(fV3) fContAllChargesV0Av3->AddSpecies("d",nPtBinsTOF,binsPtTOF);
  if(fV3) fContAllChargesV0Av3->AddSpecies("t",nPtBinsTOF,binsPtTOF);
  if(fV3) fContAllChargesV0Av3->AddSpecies("he3",nPtBinsTOF,binsPtTOF);
  if(fV3) fContAllChargesV0Av3->AddSpecies("mu",nPtBinsTOF,binsPtTOF);
  if(fV3) fContAllChargesV0Av3->AddSpecies("Ks",nPtBinsTOF,binsPtTOF);
  if(fV3) fContAllChargesV0Av3->AddSpecies("Lambda",nPtBinsTOF,binsPtTOF);
  if(fV3) fContAllChargesV0Av3->AddSpecies("pFromLambda",nPtBinsTOF,binsPtTOF);
  if(fV3) fContAllChargesV0Av3->AddSpecies("piFromK",nPtBinsTOF,binsPtTOF);

  fContAllChargesV0Cv3 = new AliFlowVZEROResults("v3C",6,binsTOF);
  fContAllChargesV0Cv3->SetVarRange(0,-0.5,nCentrBin-0.5); // centrality
  fContAllChargesV0Cv3->SetVarRange(1,-1.5,1.5);  // charge
  fContAllChargesV0Cv3->SetVarRange(2,0.6,1.0001);// prob
  fContAllChargesV0Cv3->SetVarRange(3,-TMath::Pi()/3,TMath::Pi()/3); // Psi
  fContAllChargesV0Cv3->SetVarRange(4,-0.5,2.5); // pid mask
  fContAllChargesV0Cv3->SetVarRange(5,-0.5,nDCABin-0.5); // DCA mask
  fContAllChargesV0Cv3->SetVarName(0,"centrality");
  fContAllChargesV0Cv3->SetVarName(1,"charge");
  fContAllChargesV0Cv3->SetVarName(2,"prob");
  fContAllChargesV0Cv3->SetVarName(3,"#Psi");
  fContAllChargesV0Cv3->SetVarName(4,"PIDmask");
  fContAllChargesV0Cv3->SetVarName(5,"DCAbin");
  if(fV3) fContAllChargesV0Cv3->AddSpecies("all",nPtBinsTOF,binsPtTOF);
  if(fV3) fContAllChargesV0Cv3->AddSpecies("pi",nPtBinsTOF,binsPtTOF);
  if(fV3) fContAllChargesV0Cv3->AddSpecies("k",nPtBinsTOF,binsPtTOF);
  if(fV3) fContAllChargesV0Cv3->AddSpecies("pr",nPtBinsTOF,binsPtTOF);
  if(fV3) fContAllChargesV0Cv3->AddSpecies("e",nPtBinsTOF,binsPtTOF);
  if(fV3) fContAllChargesV0Cv3->AddSpecies("d",nPtBinsTOF,binsPtTOF);
  if(fV3) fContAllChargesV0Cv3->AddSpecies("t",nPtBinsTOF,binsPtTOF);
  if(fV3) fContAllChargesV0Cv3->AddSpecies("he3",nPtBinsTOF,binsPtTOF);
  if(fV3) fContAllChargesV0Cv3->AddSpecies("mu",nPtBinsTOF,binsPtTOF);
  if(fV3) fContAllChargesV0Cv3->AddSpecies("Ks",nPtBinsTOF,binsPtTOF);
  if(fV3) fContAllChargesV0Cv3->AddSpecies("Lambda",nPtBinsTOF,binsPtTOF);
  if(fV3) fContAllChargesV0Cv3->AddSpecies("pFromLambda",nPtBinsTOF,binsPtTOF);
  if(fV3) fContAllChargesV0Cv3->AddSpecies("piFromK",nPtBinsTOF,binsPtTOF);

  fList2->Add(fContAllChargesV0Av3);
  fList2->Add(fContAllChargesV0Cv3);

  if(fIsMC && fV3){
    fContAllChargesMCAv3 = new AliFlowVZEROResults("v3mcA",5,binsTOFmcPureMC);
    fContAllChargesMCAv3->SetVarRange(0,-0.5,nCentrBin-0.5); // centrality
    fContAllChargesMCAv3->SetVarRange(1,-1.5,1.5);  // charge
    fContAllChargesMCAv3->SetVarRange(2,0.6,1.0001);// prob
    fContAllChargesMCAv3->SetVarRange(3,-TMath::Pi()/3,TMath::Pi()/3); // Psi
    fContAllChargesMCAv3->SetVarRange(4,-0.5,1.5); // pid mask
    fContAllChargesMCAv3->SetVarName(0,"centrality");
    fContAllChargesMCAv3->SetVarName(1,"charge");
    fContAllChargesMCAv3->SetVarName(2,"prob");
    fContAllChargesMCAv3->SetVarName(3,"#Psi");
    fContAllChargesMCAv3->SetVarName(4,"PIDmask");
    fContAllChargesMCAv3->AddSpecies("all",nPtBinsTOF,binsPtTOF);
    fContAllChargesMCAv3->AddSpecies("pi",nPtBinsTOF,binsPtTOF);
    fContAllChargesMCAv3->AddSpecies("k",nPtBinsTOF,binsPtTOF);
    fContAllChargesMCAv3->AddSpecies("pr",nPtBinsTOF,binsPtTOF);
    fContAllChargesMCAv3->AddSpecies("e",nPtBinsTOF,binsPtTOF);
    fContAllChargesMCAv3->AddSpecies("mu",nPtBinsTOF,binsPtTOF);
    fList3->Add(fContAllChargesMCAv3); 

    fContAllChargesMCCv3 = new AliFlowVZEROResults("v3mcC",5,binsTOFmcPureMC);
    fContAllChargesMCCv3->SetVarRange(0,-0.5,nCentrBin-0.5); // centrality
    fContAllChargesMCCv3->SetVarRange(1,-1.5,1.5);  // charge
    fContAllChargesMCCv3->SetVarRange(2,0.6,1.0001);// prob
    fContAllChargesMCCv3->SetVarRange(3,-TMath::Pi()/3,TMath::Pi()/3); // Psi
    fContAllChargesMCCv3->SetVarRange(4,-0.5,1.5); // pid mask
    fContAllChargesMCCv3->SetVarName(0,"centrality");
    fContAllChargesMCCv3->SetVarName(1,"charge");
    fContAllChargesMCCv3->SetVarName(2,"prob");
    fContAllChargesMCCv3->SetVarName(3,"#Psi");
    fContAllChargesMCCv3->SetVarName(4,"PIDmask");
    fContAllChargesMCCv3->AddSpecies("all",nPtBinsTOF,binsPtTOF);
    fContAllChargesMCCv3->AddSpecies("pi",nPtBinsTOF,binsPtTOF);
    fContAllChargesMCCv3->AddSpecies("k",nPtBinsTOF,binsPtTOF);
    fContAllChargesMCCv3->AddSpecies("pr",nPtBinsTOF,binsPtTOF);
    fContAllChargesMCCv3->AddSpecies("e",nPtBinsTOF,binsPtTOF);
    fContAllChargesMCCv3->AddSpecies("mu",nPtBinsTOF,binsPtTOF);
    fList3->Add(fContAllChargesMCCv3); 
  }

  // TProfile for resolutions 3 subevents (V0A, V0C, TPC)
  // v2
  fHResTPCv0A2 = new TProfile("hResTPCv0A2","",nCentrBin,0,nCentrBin);
  fHResTPCv0C2 = new TProfile("hResTPCv0C2","",nCentrBin,0,nCentrBin);
  fHResv0Cv0A2 = new TProfile("hResv0Cv0A2","",nCentrBin,0,nCentrBin);

  fList->Add(fHResTPCv0A2);
  fList->Add(fHResTPCv0C2);
  fList->Add(fHResv0Cv0A2);

  // v3
  fHResTPCv0A3 = new TProfile("hResTPCv0A3","",nCentrBin,0,nCentrBin);
  fHResTPCv0C3 = new TProfile("hResTPCv0C3","",nCentrBin,0,nCentrBin);
  fHResv0Cv0A3 = new TProfile("hResv0Cv0A3","",nCentrBin,0,nCentrBin);

  fList2->Add(fHResTPCv0A3);
  fList2->Add(fHResTPCv0C3);
  fList2->Add(fHResv0Cv0A3);

  // MC as in the dataEP resolution (but using MC tracks)
  if(fIsMC && fV3){
    fHResMA2 = new TProfile("hResMA2","",nCentrBin,0,nCentrBin);
    fHResMC2 = new TProfile("hResMC2","",nCentrBin,0,nCentrBin);
    fHResAC2 = new TProfile("hResAC2","",nCentrBin,0,nCentrBin);
    fList3->Add(fHResMA2); 
    fList3->Add(fHResMC2); 
    fList3->Add(fHResAC2); 
  }
  if(fIsMC && fV3){
    fHResMA3 = new TProfile("hResMA3","",nCentrBin,0,nCentrBin);
    fHResMC3 = new TProfile("hResMC3","",nCentrBin,0,nCentrBin);
    fHResAC3 = new TProfile("hResAC3","",nCentrBin,0,nCentrBin);
    fList3->Add(fHResMA3); 
    fList3->Add(fHResMC3); 
    fList3->Add(fHResAC3); 
  }


  // V0A and V0C event plane distributions
  //v2 
  fPhiRPv0A = new TH2F("fPhiRPv0Av2","#phi distribution of EP VZERO-A;centrality;#phi (rad)",nCentrBin,0,nCentrBin,nPsiTOF,-TMath::Pi()/2,TMath::Pi()/2);
  fPhiRPv0C = new TH2F("fPhiRPv0Cv2","#phi distribution of EP VZERO-C;centrality;#phi (rad)",nCentrBin,0,nCentrBin,nPsiTOF,-TMath::Pi()/2,TMath::Pi()/2);

  //v3
  fPhiRPv0Av3 = new TH2F("fPhiRPv0Av3","#phi distribution of EP VZERO-A;centrality;#phi (rad)",nCentrBin,0,nCentrBin,nPsiTOF,-TMath::Pi()/3,TMath::Pi()/3);
  fPhiRPv0Cv3 = new TH2F("fPhiRPv0Cv3","#phi distribution of EP VZERO-C;centrality;#phi (rad)",nCentrBin,0,nCentrBin,nPsiTOF,-TMath::Pi()/3,TMath::Pi()/3);

  // QA container
  // v2
  const Int_t nDETsignal = 50;
  Double_t binDETsignal[nDETsignal+1];
  for(Int_t i=0;i<nDETsignal+1;i++){
    binDETsignal[i] = -5 + i*10. / nDETsignal;
  }
//   const Int_t nEta = 5;
//   Double_t binEta[nEta+1];
//   for(Int_t i=0;i<nEta+1;i++){
//     binEta[i] = -1 + i*2. / nEta;
//   }

  const Int_t nDeltaPhi = 5;
  const Int_t nDeltaPhiV3 = 7;

  Int_t binsQA[5] = {nCentrTOF,7,5,nDeltaPhi,2};
  Int_t binsQAv3[5] = {nCentrTOF,7,5,nDeltaPhiV3,2};


  fQA = new AliFlowVZEROQA("v2AQA",5,binsQA);
  fQA->SetVarRange(0,-0.5,nCentrBin-0.5); // centrality
  fQA->SetVarRange(1,0,7);  // pt
  fQA->SetVarRange(2,0.,1.0001);// prob
  fQA->SetVarRange(3,-TMath::Pi(),TMath::Pi()); // Psi
  fQA->SetVarRange(4,-0.5,1.5); // pid mask
  fQA->SetVarName(0,"centrality");
  fQA->SetVarName(1,"p_{t}");
  fQA->SetVarName(2,"prob");
  fQA->SetVarName(3,"#Psi");
  fQA->SetVarName(4,"PIDmask");
  if(fQAsw && fV2) fQA->AddSpecies("pi",nDETsignal,binDETsignal,nDETsignal,binDETsignal);
  if(fQAsw && fV2) fQA->AddSpecies("k",nDETsignal,binDETsignal,nDETsignal,binDETsignal);
  if(fQAsw && fV2) fQA->AddSpecies("pr",nDETsignal,binDETsignal,nDETsignal,binDETsignal);
//   if(fQAsw && fV2) fQA->AddSpecies("e",nDETsignal,binDETsignal,nDETsignal,binDETsignal);
//   fQA->AddSpecies("d",nDETsignal,binDETsignal,nDETsignal,binDETsignal);
//   fQA->AddSpecies("t",nDETsignal,binDETsignal,nDETsignal,binDETsignal);
//   fQA->AddSpecies("he3",nDETsignal,binDETsignal,nDETsignal,binDETsignal);

  fQA2 = new AliFlowVZEROQA("v2CQA",5,binsQA);
  fQA2->SetVarRange(0,-0.5,nCentrBin-0.5); // centrality
  fQA2->SetVarRange(1,0,7);  // pt
  fQA2->SetVarRange(2,0.,1.0001);// prob
  fQA2->SetVarRange(3,-TMath::Pi(),TMath::Pi()); // Psi
  fQA2->SetVarRange(4,-0.5,1.5); // pid mask
  fQA2->SetVarName(0,"centrality");
  fQA2->SetVarName(1,"p_{t}");
  fQA2->SetVarName(2,"prob");
  fQA2->SetVarName(3,"#Psi");
  fQA2->SetVarName(4,"PIDmask");
  if(fQAsw && fV2) fQA2->AddSpecies("pi",nDETsignal,binDETsignal,nDETsignal,binDETsignal);
  if(fQAsw && fV2) fQA2->AddSpecies("k",nDETsignal,binDETsignal,nDETsignal,binDETsignal);
  if(fQAsw && fV2) fQA2->AddSpecies("pr",nDETsignal,binDETsignal,nDETsignal,binDETsignal);
//   if(fQAsw && fV2) fQA2->AddSpecies("e",nDETsignal,binDETsignal,nDETsignal,binDETsignal);
//   fQA2->AddSpecies("d",nDETsignal,binDETsignal,nDETsignal,binDETsignal);
//   fQA2->AddSpecies("t",nDETsignal,binDETsignal,nDETsignal,binDETsignal);
//   fQA2->AddSpecies("he3",nDETsignal,binDETsignal,nDETsignal,binDETsignal);

  fQAv3 = new AliFlowVZEROQA("v3AQA",5,binsQAv3);
  fQAv3->SetVarRange(0,-0.5,nCentrBin-0.5); // centrality
  fQAv3->SetVarRange(1,0,7);  // pt
  fQAv3->SetVarRange(2,0.,1.0001);// prob
  fQAv3->SetVarRange(3,-TMath::Pi(),TMath::Pi()); // Psi
  fQAv3->SetVarRange(4,-0.5,1.5); // pid mask
  fQAv3->SetVarName(0,"centrality");
  fQAv3->SetVarName(1,"p_{t}");
  fQAv3->SetVarName(2,"prob");
  fQAv3->SetVarName(3,"#Psi");
  fQAv3->SetVarName(4,"PIDmask");
  if(fQAsw && fV3) fQAv3->AddSpecies("pi",nDETsignal,binDETsignal,nDETsignal,binDETsignal);
//   if(fQAsw && fV3) fQAv3->AddSpecies("k",nDETsignal,binDETsignal,nDETsignal,binDETsignal);
//   if(fQAsw && fV3) fQAv3->AddSpecies("pr",nDETsignal,binDETsignal,nDETsignal,binDETsignal);
//   if(fQAsw && fV2) fQAv3->AddSpecies("e",nDETsignal,binDETsignal,nDETsignal,binDETsignal);
//   fQAv3->AddSpecies("d",nDETsignal,binDETsignal,nDETsignal,binDETsignal);
//   fQAv3->AddSpecies("t",nDETsignal,binDETsignal,nDETsignal,binDETsignal);
//   fQAv3->AddSpecies("he3",nDETsignal,binDETsignal,nDETsignal,binDETsignal);

  fQA2v3 = new AliFlowVZEROQA("v3CQA",5,binsQAv3);
  fQA2v3->SetVarRange(0,-0.5,nCentrBin-0.5); // centrality
  fQA2v3->SetVarRange(1,0,7);  // pt
  fQA2v3->SetVarRange(2,0.,1.0001);// prob
  fQA2v3->SetVarRange(3,-TMath::Pi(),TMath::Pi()); // Psi
  fQA2v3->SetVarRange(4,-0.5,1.5); // pid mask
  fQA2v3->SetVarName(0,"centrality");
  fQA2v3->SetVarName(1,"p_{t}");
  fQA2v3->SetVarName(2,"prob");
  fQA2v3->SetVarName(3,"#Psi");
  fQA2v3->SetVarName(4,"PIDmask");
  if(fQAsw && fV3) fQA2v3->AddSpecies("pi",nDETsignal,binDETsignal,nDETsignal,binDETsignal);
//   if(fQAsw && fV3) fQA2v3->AddSpecies("k",nDETsignal,binDETsignal,nDETsignal,binDETsignal);
//   if(fQAsw && fV3) fQA2v3->AddSpecies("pr",nDETsignal,binDETsignal,nDETsignal,binDETsignal);
//   if(fQAsw && fV2) fQA2v3->AddSpecies("e",nDETsignal,binDETsignal,nDETsignal,binDETsignal);
//   fQA2v3->AddSpecies("d",nDETsignal,binDETsignal,nDETsignal,binDETsignal);
//   fQA2v3->AddSpecies("t",nDETsignal,binDETsignal,nDETsignal,binDETsignal);
//   fQA2v3->AddSpecies("he3",nDETsignal,binDETsignal,nDETsignal,binDETsignal);

  fList->Add(fPhiRPv0A);
  fList->Add(fPhiRPv0C);

  if(fQAsw && fV2){
    fList4->Add(fQA);
    fList4->Add(fQA2);
  }

  fList2->Add(fPhiRPv0Av3);
  fList2->Add(fPhiRPv0Cv3);

  if(fQAsw && fV3){
   fList4->Add(fQAv3);
   fList4->Add(fQA2v3);
  }

  //  fList->Add(fTree); // comment if not needed

  const Int_t nDCA = 300;
  Double_t DCAbin[nDCA+1];
  for(Int_t i=0;i <= nDCA;i++){
    DCAbin[i] = -3 +i*6.0/nDCA;
  }
  
  char nameHistos[100];
  for(Int_t iC=0;iC < nCentrBin;iC++){
    snprintf(nameHistos,100,"fHdcaPtPiCent%i",iC);
    fHdcaPt[iC][0] = new TH2D(nameHistos,"DCA_{xy} for #pi;p_{t} (GeV/c);DCA_{xy} (cm)",nPtBinsTOF,binsPtTOF,nDCA,DCAbin);
    snprintf(nameHistos,100,"fHdcaPtKaCent%i",iC);
    fHdcaPt[iC][1] = new TH2D(nameHistos,"DCA_{xy} for K;p_{t} (GeV/c);DCA_{xy} (cm)",nPtBinsTOF,binsPtTOF,nDCA,DCAbin);
    snprintf(nameHistos,100,"fHdcaPtPrCent%i",iC);
    fHdcaPt[iC][2] = new TH2D(nameHistos,"DCA_{xy} for #bar{p};p_{t} (GeV/c);DCA_{xy} (cm)",nPtBinsTOF,binsPtTOF,nDCA,DCAbin);
    snprintf(nameHistos,100,"fHdcaPtElCent%i",iC);
    fHdcaPt[iC][3] = new TH2D(nameHistos,"DCA_{xy} for e;p_{t} (GeV/c);DCA_{xy} (cm)",nPtBinsTOF,binsPtTOF,nDCA,DCAbin);
    snprintf(nameHistos,100,"fHdcaPtDeCent%i",iC);
    fHdcaPt[iC][4] = new TH2D(nameHistos,"DCA_{xy} for #bar{d};p_{t} (GeV/c);DCA_{xy} (cm)",nPtBinsTOF,binsPtTOF,nDCA,DCAbin);
    snprintf(nameHistos,100,"fHdcaPtTrCent%i",iC);
    fHdcaPt[iC][5] = new TH2D(nameHistos,"DCA_{xy} for #bar{t};p_{t} (GeV/c);DCA_{xy} (cm)",nPtBinsTOF,binsPtTOF,nDCA,DCAbin);
    snprintf(nameHistos,100,"fHdcaPtHeCent%i",iC);
    fHdcaPt[iC][6] = new TH2D(nameHistos,"DCA_{xy} for #bar{^{3}He};p_{t} (GeV/c);DCA_{xy} (cm)",nPtBinsTOF,binsPtTOF,nDCA,DCAbin);
  }
  
  if(fFillDCA && fQAsw){
    for(Int_t i=0;i<7;i++)
      for(Int_t iC=0;iC < nCentrBin;iC++)
	fList4->Add(fHdcaPt[iC][i]);
  }
  if(fIsMC){
    for(Int_t iC=0;iC < nCentrBin;iC++){
      snprintf(nameHistos,100,"fHdcaPtPiSecCent%i",iC);
      fHdcaPtSec[iC][0] = new TH2D(nameHistos,"DCA_{xy} for secondary #pi;p_{t} (GeV/c);DCA_{xy} (cm)",nPtBinsTOF,binsPtTOF,nDCA,DCAbin);
      snprintf(nameHistos,100,"fHdcaPtKaSecCent%i",iC);
      fHdcaPtSec[iC][1] = new TH2D(nameHistos,"DCA_{xy} for secondary K;p_{t} (GeV/c);DCA_{xy} (cm)",nPtBinsTOF,binsPtTOF,nDCA,DCAbin);
      snprintf(nameHistos,100,"fHdcaPtPrSecCent%i",iC);
      fHdcaPtSec[iC][2] = new TH2D(nameHistos,"DCA_{xy} for secondary #bar{p};p_{t} (GeV/c);DCA_{xy} (cm)",nPtBinsTOF,binsPtTOF,nDCA,DCAbin);
      snprintf(nameHistos,100,"fHdcaPtElSecCent%i",iC);
      fHdcaPtSec[iC][3] = new TH2D(nameHistos,"DCA_{xy} for secondary e;p_{t} (GeV/c);DCA_{xy} (cm)",nPtBinsTOF,binsPtTOF,nDCA,DCAbin);
      snprintf(nameHistos,100,"fHdcaPtDeSecCent%i",iC);
      fHdcaPtSec[iC][4] = new TH2D(nameHistos,"DCA_{xy} for secondary #bar{d};p_{t} (GeV/c);DCA_{xy} (cm)",nPtBinsTOF,binsPtTOF,nDCA,DCAbin);
      snprintf(nameHistos,100,"fHdcaPtTrSecCent%i",iC);
      fHdcaPtSec[iC][5] = new TH2D(nameHistos,"DCA_{xy} for secondary #bar{t};p_{t} (GeV/c);DCA_{xy} (cm)",nPtBinsTOF,binsPtTOF,nDCA,DCAbin);
      snprintf(nameHistos,100,"fHdcaPtHeSecCent%i",iC);
      fHdcaPtSec[iC][6] = new TH2D(nameHistos,"DCA_{xy} for secondary #bar{^{3}He};p_{t} (GeV/c);DCA_{xy} (cm)",nPtBinsTOF,binsPtTOF,nDCA,DCAbin);
    }
    
    if(fFillDCA && fQAsw){
      for(Int_t i=0;i<7;i++)
	for(Int_t iC=0;iC < nCentrBin;iC++)
	  fList4->Add(fHdcaPtSec[iC][i]);
    }
  }
  
  // Add TProfile Extra QA
  const Int_t nBinQApid = 2;
  Int_t binQApid[nBinQApid] = {nCentrTOF,200};
  const Int_t nbinsigma = 100;
  Double_t nsigmaQA[nbinsigma+1];
  for(Int_t i=0;i<nbinsigma+1;i++){
    nsigmaQA[i] = -10 + 20.0*i/nbinsigma;
  }
  fContQApid = new AliFlowVZEROResults("qaPID",nBinQApid,binQApid);
  fContQApid->SetVarRange(0,-0.5,nCentrBin-0.5); // centrality
  fContQApid->SetVarRange(1,0,20);  // charge
  fContQApid->SetVarName(0,"centrality");
  fContQApid->SetVarName(1,"p_{t}");
  fContQApid->AddSpecies("piTPC",nbinsigma,nsigmaQA);
  fContQApid->AddSpecies("piTOF",nbinsigma,nsigmaQA);
  fContQApid->AddSpecies("kaTPC",nbinsigma,nsigmaQA);
  fContQApid->AddSpecies("kaTOF",nbinsigma,nsigmaQA);
  fContQApid->AddSpecies("prTPC",nbinsigma,nsigmaQA);
  fContQApid->AddSpecies("prTOF",nbinsigma,nsigmaQA);
  if(fV2) fList->Add(fContQApid);
  
  printf("Output creation ok!!\n\n\n\n");

  fList->Add(fHctauPtEP);
  fList->Add(fHctauAt1EP);

  fHKsPhi = new TH2D("hKsPhi","K^{0}_{s} #phi distributuion;v_{z} (cm);#phi (rad)",20,-10,10,20,0,2*TMath::Pi());
  fList->Add(fHKsPhi);
  fHKsPhiEP = new TH2D("hKsPhiEP","EP V0C #phi distributuion;v_{z} (cm);#phi (rad)",20,-10,10,20,0,2*TMath::Pi());
  fList->Add(fHKsPhiEP);

  fHK0sMass = new TH2D("hK0sMass","K^{0}_{s} mass;p_{T} (GeV/#it{c});mass (GeV/#it{c}^{2})",20,0,5,400,0,1);
  fList->Add(fHK0sMass);
  fHK0sMass2 = new TH2D("hK0sMass2","K^{0}_{s} mass using secondary vertex;p_{T} (GeV/#it{c});mass (GeV/#it{c}^{2})",20,0,5,400,0,1);
  fList->Add(fHK0sMass2);

  fHK0vsLambda= new TH2D("hK0vsLambda",";K^{0} mass;#Lambda mass",100,0,1,100,0.5,1.5);
  fList->Add(fHK0vsLambda);

  // Post output data.
  if(fV2) PostData(1, fList);
  if(fV3) PostData(2, fList2);
  if(fIsMC) PostData(3, fList3);
  if(fQAsw) PostData(4, fList4);

}

//______________________________________________________________________________
void AliAnalysisTaskVnV0::UserExec(Option_t *) 
{
    // Main loop
    // Called for each event
    
    fgIsPsiComputed = kFALSE;
    fgPsi2v0a=999.;
    fgPsi2v0c=999.;
    fgPsi2tpc=999.;
    fgPsi3v0a=999.;
    fgPsi3v0c=999.;
    fgPsi3tpc=999.;
    fgPsi2v0aMC=999.;
    fgPsi2v0cMC=999.;
    fgPsi2tpcMC=999.;
    fgPsi3v0aMC=999.;
    fgPsi3v0cMC=999.;
    fgPsi3tpcMC=999.;

    fOutputAOD = dynamic_cast<AliAODEvent*>(InputEvent());
    if(!fOutputAOD){
	Printf("%s:%d AODEvent not found in Input Manager",(char*)__FILE__,__LINE__);
	this->Dump();
	return;
    }
    
    Int_t run = fOutputAOD->GetRunNumber();

    if(run != fRun){
	// Load the calibrations run dependent
      if(! fIsAfter2011) OpenInfoCalbration(run);
      fRun=run;
    }

    fZvtx = GetVertex(fOutputAOD);



    //Get the MC object
    if(fIsMC){
      AliAODMCHeader *mcHeader = dynamic_cast<AliAODMCHeader*>(fOutputAOD->GetList()->FindObject(AliAODMCHeader::StdBranchName()));
      if (!mcHeader) {
	AliError("Could not find MC Header in AOD");
	return;
      }
    }

    /*
    AliMCEvent* mcEvent = MCEvent();
    if (!mcEvent) {
      Printf("ERROR: Could not retrieve MC event");
      return;
    }
    
    Double_t gReactionPlane = -999., gImpactParameter = -999.;
    //Get the MC header
    AliGenHijingEventHeader* headerH = dynamic_cast<AliGenHijingEventHeader*>(mcEvent->GenEventHeader());
    if (headerH) {
      //Printf("=====================================================");
      //Printf("Reaction plane angle: %lf",headerH->ReactionPlaneAngle());
      //Printf("=====================================================");
      gReactionPlane = headerH->ReactionPlaneAngle();
      gImpactParameter = headerH->ImpactParameter();
    }

*/

    if (TMath::Abs(fZvtx) < fVtxCut) {
      //Centrality
      Float_t v0Centr  = -10.;
      Float_t trkCentr  = -10.;
      AliCentrality *centrality = fOutputAOD->GetCentrality();
      if (centrality){
//	printf("v0centr = %f -- tpccnetr%f\n",centrality->GetCentralityPercentile("V0M"),centrality->GetCentralityPercentile("TRK"));
 	v0Centr  = centrality->GetCentralityPercentile("V0M");
 	trkCentr = centrality->GetCentralityPercentile("TRK"); 
	//changed
      }

      if(TMath::Abs(v0Centr - trkCentr) < 5.0 && v0Centr > 0){ // consistency cut on centrality selection
	fPID->SetDetResponse(fOutputAOD, v0Centr); // Set the PID object for each event!!!!
	Analyze(fOutputAOD,v0Centr); // Do analysis!!!!

        fCentrality = v0Centr;
        if(fV2) fTree->Fill();
      }
    }
    
}

//________________________________________________________________________
void AliAnalysisTaskVnV0::Analyze(AliAODEvent* aodEvent, Float_t v0Centr)
{      

  Int_t nusedForK0s=0;
  AliAODTrack *usedForK0s1[1000];
  AliAODTrack *usedForK0s2[1000];

  Float_t mass[8] = {5.10998909999999971e-04, 1.05658000000000002e-01, 1.39570000000000000e-01, 4.93676999999999977e-01, 9.38271999999999995e-01,1.87783699999999998,2.81740199999999996,1.40805449999999999};
  
  // Event plane resolution for v2
  Float_t evPlRes[18] = {0.350582,0.505393,0.607845,0.632913,0.592230,0.502489,0.381717,0.249539,0.133180, // V0A vs. centrality
			 0.446480,0.612705,0.712222,0.736200,0.697907,0.610114,0.481009,0.327402,0.182277};// V0C vs. centrality
  
  Int_t iC = -1;    
  if (v0Centr < 80){ // analysis only for 0-80% centrality classes
    //  if (v0Centr >0 && v0Centr < 80){ // analysis only for 0-80% centrality classes
    // changed
    fgIsPsiComputed = kTRUE;

    // centrality bins
    if(v0Centr < 5) iC = 0;
    else if(v0Centr < 10) iC = 1;
    else if(v0Centr < 20) iC = 2;
    else if(v0Centr < 30) iC = 3;
    else if(v0Centr < 40) iC = 4;
    else if(v0Centr < 50) iC = 5;
    else if(v0Centr < 60) iC = 6;
    else if(v0Centr < 70) iC = 7;
    else iC = 8;

    Int_t iCcal = iC;

/*
    if(nCentrBin==16){
       iC = v0Centr/5;
       if(iC >= nCentrBin) iC = nCentrBin-1;
    }

    // centrality bins
    // changed
    if(v0Centr < 10 + 10./9) iC = 0;
    else if(v0Centr < 10 + 20./9) iC = 1;
    else if(v0Centr < 10 + 30./9) iC = 2;
    else if(v0Centr < 10 + 40./9) iC = 3;
    else if(v0Centr < 10 + 50./9) iC = 4;
    else if(v0Centr < 10 + 60./9) iC = 5;
    else if(v0Centr < 10 + 70./9) iC = 6;
    else if(v0Centr < 10 + 90./9) iC = 7;
    else if(v0Centr < 10 + 100./9) iC = 8;
    else if(v0Centr < 10 + 110./9) iC = 9;
    else if(v0Centr < 10 + 120./9) iC = 10;
    else if(v0Centr < 10 + 130./9) iC = 11;
    else if(v0Centr < 10 + 140./9) iC = 12;
    else if(v0Centr < 10 + 150./9) iC = 13;
    else if(v0Centr < 10 + 160./9) iC = 14;
    else if(v0Centr < 10 + 170./9) iC = 15;
    else iC = 16;
    if(iC >= nCentrBin) iC= nCentrBin - 1;
*/

    //reset Q vector info	
    Double_t Qxa2 = 0, Qya2 = 0;
    Double_t Qxc2 = 0, Qyc2 = 0;
    Double_t Qxa3 = 0, Qya3 = 0;
    Double_t Qxc3 = 0, Qyc3 = 0;

    Int_t nAODTracks = aodEvent->GetNumberOfTracks();

    AliAODMCHeader *mcHeader = NULL;
    TClonesArray *mcArray = NULL;
    Float_t evplaneMC = 0;
    if(fIsMC){
      mcHeader = dynamic_cast<AliAODMCHeader*>(fOutputAOD->GetList()->FindObject(AliAODMCHeader::StdBranchName()));

      if (mcHeader) {	
	evplaneMC = mcHeader->GetReactionPlaneAngle();
	if(evplaneMC > TMath::Pi()/2 && evplaneMC <=  TMath::Pi()*3/2) evplaneMC-=TMath::Pi(); 
	else if(evplaneMC > TMath::Pi()*3/2) evplaneMC-=2*TMath::Pi(); 
	mcArray = (TClonesArray*)fOutputAOD->GetList()->FindObject(AliAODMCParticle::StdBranchName());
      
	if(mcArray){
	  Float_t QxMCv2[3] = {0,0,0};
	  Float_t QyMCv2[3] = {0,0,0};
	  Float_t QxMCv3[3] = {0,0,0};
	  Float_t QyMCv3[3] = {0,0,0};
	  Float_t EvPlaneMCV2[3] = {0,0,0};
	  Float_t EvPlaneMCV3[3] = {0,0,0};
	  Float_t etaMin[3] = {2.8,-3.6,-0.8}; // A-side, C-side M-barrel
	  Float_t etaMax[3] = {4.88,-1.8,0.8};

	  // analysis on MC tracks
	  Int_t nMCtrack = mcArray->GetEntries() ;

	  // EP computation with MC tracks
	  for(Int_t iT=0;iT < nMCtrack;iT++){
	    AliAODMCParticle *mctr = (AliAODMCParticle*) mcArray->At(iT);
	    if(!mctr || !(mctr->IsPrimary()) || !(mctr->Charge()) || mctr->Pt() < 0.2) continue;
	    
	    Float_t eta = mctr->Eta();
	    
	    for(Int_t iD=0;iD<3;iD++){
	      if(eta > etaMin[iD] && eta < etaMax[iD]){
		Float_t phi = mctr->Phi();
		QxMCv2[iD] += TMath::Cos(2*phi);
		QyMCv2[iD] += TMath::Sin(2*phi);
		QxMCv3[iD] += TMath::Cos(3*phi);
		QyMCv3[iD] += TMath::Sin(3*phi);
	      }
	    }
	  }

	  if(fV2){
	    EvPlaneMCV2[0] = TMath::ATan2(QyMCv2[0],QxMCv2[0])/2.;
	    EvPlaneMCV2[1] = TMath::ATan2(QyMCv2[1],QxMCv2[1])/2.;
	    EvPlaneMCV2[2] = TMath::ATan2(QyMCv2[2],QxMCv2[2])/2.;
	    fHResMA2->Fill(Double_t(iC), TMath::Cos(2*(EvPlaneMCV2[2]-EvPlaneMCV2[0])));
	    fHResMC2->Fill(Double_t(iC), TMath::Cos(2*(EvPlaneMCV2[2]-EvPlaneMCV2[1])));
	    fHResAC2->Fill(Double_t(iC), TMath::Cos(2*(EvPlaneMCV2[0]-EvPlaneMCV2[1])));
            fgPsi2v0aMC = EvPlaneMCV2[0];
            fgPsi2v0cMC = EvPlaneMCV2[1];
            fgPsi2tpcMC = EvPlaneMCV2[2];
	  }
	  if(fV3){
	    EvPlaneMCV3[0] = TMath::ATan2(QyMCv3[0],QxMCv3[0])/3.;
	    EvPlaneMCV3[1] = TMath::ATan2(QyMCv3[1],QxMCv3[1])/3.;
	    EvPlaneMCV3[2] = TMath::ATan2(QyMCv3[2],QxMCv3[2])/3.;
	    fHResMA3->Fill(Double_t(iC), TMath::Cos(3*(EvPlaneMCV3[2]-EvPlaneMCV3[0])));
	    fHResMC3->Fill(Double_t(iC), TMath::Cos(3*(EvPlaneMCV3[2]-EvPlaneMCV3[1])));
	    fHResAC3->Fill(Double_t(iC), TMath::Cos(3*(EvPlaneMCV3[0]-EvPlaneMCV3[1])));
            fgPsi3v0aMC = EvPlaneMCV3[0];
            fgPsi3v0cMC = EvPlaneMCV3[1];
            fgPsi3tpcMC = EvPlaneMCV3[2];
	  }

	  // flow A and C side
	  Float_t xMCepAv2[5] = {static_cast<Float_t>(iC),0/*charge*/,1,EvPlaneMCV2[0],1};
	  Float_t xMCepCv2[5] = {static_cast<Float_t>(iC),0/*charge*/,1,EvPlaneMCV2[1],1};
	  Float_t xMCepAv3[5] = {static_cast<Float_t>(iC),0/*charge*/,1,EvPlaneMCV3[0],1};
	  Float_t xMCepCv3[5] = {static_cast<Float_t>(iC),0/*charge*/,1,EvPlaneMCV3[1],1};
	  
	  for(Int_t iT=0;iT < nMCtrack;iT++){
	    AliAODMCParticle *mctr = (AliAODMCParticle*) mcArray->At(iT);
	    if(!mctr || !(mctr->IsPhysicalPrimary()) || !(mctr->Charge()) || TMath::Abs(mctr->Eta()) > 0.8 || mctr->Pt() < 0.2) continue;
	    Int_t iS = TMath::Abs(mctr->GetPdgCode());
	    Int_t charge = mctr->Charge();
	    Float_t pt = mctr->Pt();
	    Float_t phi = mctr->Phi();

	    if(charge > 0){
	      xMCepAv2[1] = 1;
	      xMCepCv2[1] = 1;
	      xMCepAv3[1] = 1;
	      xMCepCv3[1] = 1;
	    }
	    else{
	      xMCepAv2[1] = -1;
	      xMCepCv2[1] = -1;
	      xMCepAv3[1] = -1;
	      xMCepCv3[1] = -1;
	    }

	    fContAllChargesMCA->Fill(0,pt, TMath::Cos(2*(phi - EvPlaneMCV2[0])),xMCepAv2);
	    fContAllChargesMCC->Fill(0,pt, TMath::Cos(2*(phi - EvPlaneMCV2[1])),xMCepCv2);
	    fContAllChargesMCAv3->Fill(0,pt, TMath::Cos(3*(phi - EvPlaneMCV3[0])),xMCepAv3);
	    fContAllChargesMCCv3->Fill(0,pt, TMath::Cos(3*(phi - EvPlaneMCV3[1])),xMCepCv3);

	    if(iS==11){
	      fContAllChargesMCA->Fill(4,pt, TMath::Cos(2*(phi - EvPlaneMCV2[0])),xMCepAv2);
	      fContAllChargesMCC->Fill(4,pt, TMath::Cos(2*(phi - EvPlaneMCV2[1])),xMCepCv2);
	      fContAllChargesMCAv3->Fill(4,pt, TMath::Cos(3*(phi - EvPlaneMCV3[0])),xMCepAv3);
	      fContAllChargesMCCv3->Fill(4,pt, TMath::Cos(3*(phi - EvPlaneMCV3[1])),xMCepCv3);
	    }
	    else if(iS==13){
	      fContAllChargesMCA->Fill(5,pt, TMath::Cos(2*(phi - EvPlaneMCV2[0])),xMCepAv2);
	      fContAllChargesMCC->Fill(5,pt, TMath::Cos(2*(phi - EvPlaneMCV2[1])),xMCepCv2);
	      fContAllChargesMCAv3->Fill(5,pt, TMath::Cos(3*(phi - EvPlaneMCV3[0])),xMCepAv3);
	      fContAllChargesMCCv3->Fill(5,pt, TMath::Cos(3*(phi - EvPlaneMCV3[1])),xMCepCv3);
	    }
	    else if(iS==211){
	      fContAllChargesMCA->Fill(1,pt, TMath::Cos(2*(phi - EvPlaneMCV2[0])),xMCepAv2);
	      fContAllChargesMCC->Fill(1,pt, TMath::Cos(2*(phi - EvPlaneMCV2[1])),xMCepCv2);
	      fContAllChargesMCAv3->Fill(1,pt, TMath::Cos(3*(phi - EvPlaneMCV3[0])),xMCepAv3);
	      fContAllChargesMCCv3->Fill(1,pt, TMath::Cos(3*(phi - EvPlaneMCV3[1])),xMCepCv3);
	    }
	    else if(iS==321){
	      fContAllChargesMCA->Fill(2,pt, TMath::Cos(2*(phi - EvPlaneMCV2[0])),xMCepAv2);
	      fContAllChargesMCC->Fill(2,pt, TMath::Cos(2*(phi - EvPlaneMCV2[1])),xMCepCv2);
	      fContAllChargesMCAv3->Fill(2,pt, TMath::Cos(3*(phi - EvPlaneMCV3[0])),xMCepAv3);
	      fContAllChargesMCCv3->Fill(2,pt, TMath::Cos(3*(phi - EvPlaneMCV3[1])),xMCepCv3);
	    }
	    else if(iS==2212){
	      fContAllChargesMCA->Fill(3,pt, TMath::Cos(2*(phi - EvPlaneMCV2[0])),xMCepAv2);
	      fContAllChargesMCC->Fill(3,pt, TMath::Cos(2*(phi - EvPlaneMCV2[1])),xMCepCv2);
	      fContAllChargesMCAv3->Fill(3,pt, TMath::Cos(3*(phi - EvPlaneMCV3[0])),xMCepAv3);
	      fContAllChargesMCCv3->Fill(3,pt, TMath::Cos(3*(phi - EvPlaneMCV3[1])),xMCepCv3);
	    }
	  }
	}
      }
    }

    // TPC EP needed for resolution studies (TPC subevent)
    Double_t Qx2 = 0, Qy2 = 0;
    Double_t Qx3 = 0, Qy3 = 0;

    for(Int_t iT = 0; iT < nAODTracks; iT++) {
      
      AliAODTrack* aodTrack = dynamic_cast<AliAODTrack*>(aodEvent->GetTrack(iT));
      if(!aodTrack) AliFatal("Not a standard AOD");
      
      if (!aodTrack){
	continue;
      }
      
      Bool_t trkFlag = aodTrack->TestFilterBit(1);

      if ((TMath::Abs(aodTrack->Eta()) > 0.8) || (aodTrack->Pt() < 0.2) || (aodTrack->GetTPCNcls() < fNcluster)  || !trkFlag) 
	continue;
	
      Double_t b[2] = {-99., -99.};
      Double_t bCov[3] = {-99., -99., -99.};


      AliAODTrack param(*aodTrack);
      if (!param.PropagateToDCA(fOutputAOD->GetPrimaryVertex(), fOutputAOD->GetMagneticField(), 100., b, bCov)){
	continue;
      }
	    
      if ((TMath::Abs(b[0]) > 3.0) || (TMath::Abs(b[1]) > 2.4))
	continue;
      
      Qx2 += TMath::Cos(2*aodTrack->Phi()); 
      Qy2 += TMath::Sin(2*aodTrack->Phi());
      Qx3 += TMath::Cos(3*aodTrack->Phi()); 
      Qy3 += TMath::Sin(3*aodTrack->Phi());
      
    }
    
    evPlAng2 = TMath::ATan2(Qy2, Qx2)/2.;
    evPlAng3 = TMath::ATan2(Qy3, Qx3)/3.;

    fgPsi2tpc = evPlAng2;
    fgPsi3tpc = evPlAng3;

    SelectK0s();

    //V0 info    
    AliAODVZERO* aodV0 = aodEvent->GetVZEROData();

    for (Int_t iv0 = 0; iv0 < 64; iv0++) {
      Double_t phiV0 = TMath::PiOver4()*(0.5 + iv0 % 8);
      Float_t multv0 = aodV0->GetMultiplicity(iv0);

      if(! fIsAfter2011){
	if(! fIsMC){
	  if (iv0 < 32){ // V0C
	    Qxc2 += TMath::Cos(2*phiV0) * multv0*fV0Cpol/fMultV0->GetBinContent(iv0+1);
	    Qyc2 += TMath::Sin(2*phiV0) * multv0*fV0Cpol/fMultV0->GetBinContent(iv0+1);
	    Qxc3 += TMath::Cos(3*phiV0) * multv0*fV0Cpol/fMultV0->GetBinContent(iv0+1);
	    Qyc3 += TMath::Sin(3*phiV0) * multv0*fV0Cpol/fMultV0->GetBinContent(iv0+1);
	  } else {       // V0A
	    Qxa2 += TMath::Cos(2*phiV0) * multv0*fV0Apol/fMultV0->GetBinContent(iv0+1);
	    Qya2 += TMath::Sin(2*phiV0) * multv0*fV0Apol/fMultV0->GetBinContent(iv0+1);
	    Qxa3 += TMath::Cos(3*phiV0) * multv0*fV0Apol/fMultV0->GetBinContent(iv0+1);
	    Qya3 += TMath::Sin(3*phiV0) * multv0*fV0Apol/fMultV0->GetBinContent(iv0+1);
	  }
	}
	else{
	  if (iv0 < 32){ // V0C
	    Qxc2 += TMath::Cos(2*phiV0) * multv0;//*fV0Cpol/fMultV0->GetBinContent(iv0+1);
	    Qyc2 += TMath::Sin(2*phiV0) * multv0;//*fV0Cpol/fMultV0->GetBinContent(iv0+1);
	    Qxc3 += TMath::Cos(3*phiV0) * multv0;//*fV0Cpol/fMultV0->GetBinContent(iv0+1);
	    Qyc3 += TMath::Sin(3*phiV0) * multv0;//*fV0Cpol/fMultV0->GetBinContent(iv0+1);
	  } else {       // V0A
	    Qxa2 += TMath::Cos(2*phiV0) * multv0;//*fV0Apol/fMultV0->GetBinContent(iv0+1);
	    Qya2 += TMath::Sin(2*phiV0) * multv0;//*fV0Apol/fMultV0->GetBinContent(iv0+1);
	    Qxa3 += TMath::Cos(3*phiV0) * multv0;//*fV0Apol/fMultV0->GetBinContent(iv0+1);
	    Qya3 += TMath::Sin(3*phiV0) * multv0;//*fV0Apol/fMultV0->GetBinContent(iv0+1);
	  }
	}
      }
    }

    //grab for each centrality the proper histo with the Qx and Qy to do the recentering
    Double_t Qxamean2 = fMeanQ[iCcal][1][0];
    Double_t Qxarms2  = fWidthQ[iCcal][1][0];
    Double_t Qyamean2 = fMeanQ[iCcal][1][1];
    Double_t Qyarms2  = fWidthQ[iCcal][1][1];
    Double_t Qxamean3 = fMeanQv3[iCcal][1][0];
    Double_t Qxarms3  = fWidthQv3[iCcal][1][0];
    Double_t Qyamean3 = fMeanQv3[iCcal][1][1];
    Double_t Qyarms3  = fWidthQv3[iCcal][1][1];
    
    Double_t Qxcmean2 = fMeanQ[iCcal][0][0];
    Double_t Qxcrms2  = fWidthQ[iCcal][0][0];
    Double_t Qycmean2 = fMeanQ[iCcal][0][1];
    Double_t Qycrms2  = fWidthQ[iCcal][0][1];	
    Double_t Qxcmean3 = fMeanQv3[iCcal][0][0];
    Double_t Qxcrms3  = fWidthQv3[iCcal][0][0];
    Double_t Qycmean3 = fMeanQv3[iCcal][0][1];
    Double_t Qycrms3  = fWidthQv3[iCcal][0][1];	
    
    Double_t QxaCor2 = (Qxa2 - Qxamean2)/Qxarms2;
    Double_t QyaCor2 = (Qya2 - Qyamean2)/Qyarms2;
    Double_t QxcCor2 = (Qxc2 - Qxcmean2)/Qxcrms2;
    Double_t QycCor2 = (Qyc2 - Qycmean2)/Qycrms2;
    Double_t QxaCor3 = (Qxa3 - Qxamean3)/Qxarms3;
    Double_t QyaCor3 = (Qya3 - Qyamean3)/Qyarms3;
    Double_t QxcCor3 = (Qxc3 - Qxcmean3)/Qxcrms3;
    Double_t QycCor3 = (Qyc3 - Qycmean3)/Qycrms3;
	
    if(! fIsAfter2011){
      if(! fIsMC){
	evPlAngV0ACor2 = TMath::ATan2(QyaCor2, QxaCor2)/2.;
	evPlAngV0CCor2 = TMath::ATan2(QycCor2, QxcCor2)/2.;
	evPlAngV0ACor3 = TMath::ATan2(QyaCor3, QxaCor3)/3.;
	evPlAngV0CCor3 = TMath::ATan2(QycCor3, QxcCor3)/3.;
      }
      else{
	evPlAngV0ACor2 = TMath::ATan2(Qya2, Qxa2)/2.;
	evPlAngV0CCor2 = TMath::ATan2(Qyc2, Qxc2)/2.;
	evPlAngV0ACor3 = TMath::ATan2(Qya3, Qxa3)/3.;
	evPlAngV0CCor3 = TMath::ATan2(Qyc3, Qxc3)/3.;
      }
    }
    else{
      AliEventplane *ep =  aodEvent->GetEventplane();
      evPlAngV0ACor2 = ep->GetEventplane("V0A", aodEvent, 2);
      evPlAngV0CCor2 = ep->GetEventplane("V0C", aodEvent, 2);
      evPlAngV0ACor3 = ep->GetEventplane("V0A", aodEvent, 3);
      evPlAngV0CCor3 = ep->GetEventplane("V0C", aodEvent, 3);
    }


    fgPsi2v0a = evPlAngV0ACor2;
    fgPsi2v0c = evPlAngV0CCor2;
    fgPsi3v0a = evPlAngV0ACor3;
    fgPsi3v0c = evPlAngV0CCor3;

    fHKsPhiEP->Fill(fZvtx,fgPsi2v0c);				 
    //loop track and get pid
    for(Int_t iT = 0; iT < nAODTracks; iT++) { // loop on the tracks
      AliAODTrack* aodTrack = dynamic_cast<AliAODTrack*>(aodEvent->GetTrack(iT));
      if(!aodTrack) AliFatal("Not a standard AOD");
	
      if (!aodTrack){
	continue;
      }
      
      Bool_t trkFlag = aodTrack->TestFilterBit(1); // TPC only tracks
      if(fFillDCA) 
	trkFlag = aodTrack->TestFilterBit(4); // Global track, DCA loose cut

      if ((TMath::Abs(aodTrack->Eta()) > fEtaCut) || (aodTrack->Pt() < fMinPt) || (aodTrack->GetTPCNcls() < fNcluster) || !trkFlag){
	continue;
      }

      Double_t b[2] = {-99., -99.};
      Double_t bCov[3] = {-99., -99., -99.};

      AliAODTrack param(*aodTrack);
      if (!param.PropagateToDCA(fOutputAOD->GetPrimaryVertex(), fOutputAOD->GetMagneticField(), 100., b, bCov)){
        continue;
      }
	    
      if (!fFillDCA && ((TMath::Abs(b[0]) > 3.0) || (TMath::Abs(b[1]) > 2.4)))
	continue;
      
      if(fFillDCA && (TMath::Abs(b[0]) > 3.0 || TMath::Abs(b[1]) > 3))
 	continue;
      
      // re-map the container in an array to do the analysis for V0A and V0C within a loop
      Float_t evPlAngV0[2] = {evPlAngV0ACor2,evPlAngV0CCor2};
      AliFlowVZEROResults *contV0[2] = {fContAllChargesV0A,fContAllChargesV0C};
      AliFlowVZEROQA *QA[2] = {fQA,fQA2};

      Float_t evPlAngV0v3[2] = {evPlAngV0ACor3,evPlAngV0CCor3};
      AliFlowVZEROResults *contV0v3[2] = {fContAllChargesV0Av3,fContAllChargesV0Cv3};
      AliFlowVZEROQA *QAv3[2] = {fQAv3,fQA2v3};

      // Fill MC results
      if(fIsMC && mcArray){
	fPID->ComputeProb(aodTrack,fOutputAOD); // compute Bayesian probabilities
	Float_t tofMismProbMC = fPID->GetTOFMismProb(); // TOF mismatch probability requested to be lower than 50% for TOF analysis 

	Float_t xMC[5] = {static_cast<Float_t>(iC),static_cast<Float_t>(aodTrack->Charge()),1,static_cast<Float_t>(evplaneMC),static_cast<Float_t>(fPID->GetCurrentMask(1)&&tofMismProbMC < 0.5)}; // to fill analysis v2 container

	Float_t v2mc = TMath::Cos(2*(aodTrack->Phi() - evplaneMC));

	fContAllChargesMC->Fill(0,aodTrack->Pt(),v2mc,xMC);
	
	Int_t iS = TMath::Abs(((AliAODMCParticle*)mcArray->At(TMath::Abs(aodTrack->GetLabel())))->GetPdgCode());
	if(iS==11){
	  fContAllChargesMC->Fill(4,aodTrack->Pt(),v2mc,xMC);
	}
	else if(iS==13){
	  fContAllChargesMC->Fill(5,aodTrack->Pt(),v2mc,xMC);	  
	}
	else if(iS==211){
	  fContAllChargesMC->Fill(1,aodTrack->Pt(),v2mc,xMC);
	}
	else if(iS==321){
	  fContAllChargesMC->Fill(2,aodTrack->Pt(),v2mc,xMC);
	}
	else if(iS==2212){
	  fContAllChargesMC->Fill(3,aodTrack->Pt(),v2mc,xMC);	  
	}
      }

      for(Int_t iV0=0;iV0<2;iV0++){ // loop on A and C side

	if(fModulationDEDx) fPID->SetPsiCorrectionDeDx(evPlAngV0[iV0],evPlRes[iV0*8+iC]); // set the PID dE/dx correction as a function of the v2-EP (resolution is needed)

	Float_t v2V0 = TMath::Cos(2*(aodTrack->Phi() - evPlAngV0[iV0]));
	Float_t v3V0 = TMath::Cos(3*(aodTrack->Phi() - evPlAngV0v3[iV0]));

	fPID->ComputeProb(aodTrack,fOutputAOD); // compute Bayesian probabilities
	Float_t dedx = fPID->GetDeDx();//aodTrack->GetTPCsignal();
	Float_t *probRead = fPID->GetProb();
	Float_t prob[8] = {probRead[0],probRead[1],probRead[2],probRead[3],probRead[4],probRead[5],probRead[6],probRead[7]};
	Float_t tofMismProb = fPID->GetTOFMismProb(); // TOF mismatch probability requested to be lower than 50% for TOF analysis 
	Float_t x[6] = {static_cast<Float_t>(iC),static_cast<Float_t>(aodTrack->Charge()),1,static_cast<Float_t>(evPlAngV0[iV0]),static_cast<Float_t>(fPID->GetCurrentMask(1)&&tofMismProb < 0.5),0}; // to fill analysis v2 container
	Float_t x3[6] = {static_cast<Float_t>(iC),static_cast<Float_t>(aodTrack->Charge()),1,static_cast<Float_t>(evPlAngV0v3[iV0]),static_cast<Float_t>(fPID->GetCurrentMask(1)&&tofMismProb < 0.5),0}; // to fill analysis v3 container

	// in case fill DCA info
	if(fFillDCA){
	  if(TMath::Abs(b[0]) > 0.1){
	    x[5] = 1;
	    x3[5] = 1;
	  }
	  if(TMath::Abs(b[0]) > 0.3){
	    x[5] = 2;
	    x3[5] = 2;
	  }
	  if(fIsMC && mcArray){
	    if(!((AliAODMCParticle*)mcArray->At(TMath::Abs(aodTrack->GetLabel())))->IsPhysicalPrimary()){
	      x[5] += 3;
	      x3[5] += 3;
	    }
	  }
	}

	// Fill no PID
	if(fV2) contV0[iV0]->Fill(0,aodTrack->Pt(),v2V0,x);
	if(fV3) contV0v3[iV0]->Fill(0,aodTrack->Pt(),v3V0,x3);


	Double_t dedxExp[8];
	Float_t tof = -1;
	Double_t inttimes[8] = {0.,0.,0.,0.,0.,0.,0.,0.};
	Double_t expTOFsigma[8] = {0.,0.,0.,0.,0.,0.,0.,0.};

	Float_t nsigmaTPC[8];
	Float_t nsigmaTOF[8];

	if(aodTrack->GetDetPid()){ // check the PID object is available
	  for(Int_t iS=0;iS < 8;iS++){
	    dedxExp[iS] = fPID->GetExpDeDx(aodTrack,iS);
	    nsigmaTPC[iS] = (dedx - dedxExp[iS])/(dedxExp[iS]*0.07);
	    //	    printf("TPC %i = %f (%f %f)\n",iS, nsigmaTPC[iS],dedx, dedxExp[iS]);
	  }
	  		
	  if(fPID->GetCurrentMask(1)){ // if TOF is present
	    Float_t ptrack = aodTrack->P();
	    tof = aodTrack->GetTOFsignal() - fPID->GetESDpid()->GetTOFResponse().GetStartTime(ptrack);
	    aodTrack->GetIntegratedTimes(inttimes);
	    
	    for(Int_t iS=5;iS < 8;iS++) // extra info for light nuclei
	      inttimes[iS] = inttimes[0] / ptrack * mass[iS] * TMath::Sqrt(1+ptrack*ptrack/mass[iS]/mass[iS]);
	    
	    for(Int_t iS=0;iS<8;iS++){
	      expTOFsigma[iS] = fPID->GetESDpid()->GetTOFResponse().GetExpectedSigma(ptrack, inttimes[iS], mass[iS]);
	      nsigmaTOF[iS] = (tof - inttimes[iS])/expTOFsigma[iS];
	      //	      printf("TOF %i = %f\n",iS, nsigmaTOF[iS]);
	    }
	  }
	}

	Float_t deltaPhiV0 = aodTrack->Phi() - evPlAngV0[iV0];
	if(deltaPhiV0 > TMath::Pi()) deltaPhiV0 -= 2*TMath::Pi();
	else if(deltaPhiV0 < -TMath::Pi()) deltaPhiV0 += 2*TMath::Pi();
	if(deltaPhiV0 > TMath::Pi()) deltaPhiV0 -= 2*TMath::Pi();
	else if(deltaPhiV0 < -TMath::Pi()) deltaPhiV0 += 2*TMath::Pi();
	
	Float_t deltaPhiV0v3 = aodTrack->Phi() - evPlAngV0v3[iV0];
	if(deltaPhiV0v3 > TMath::Pi()) deltaPhiV0v3 -= 2*TMath::Pi();
	else if(deltaPhiV0v3 < -TMath::Pi()) deltaPhiV0v3 += 2*TMath::Pi();
	if(deltaPhiV0v3 > TMath::Pi()) deltaPhiV0v3 -= 2*TMath::Pi();
	else if(deltaPhiV0v3 < -TMath::Pi()) deltaPhiV0v3 += 2*TMath::Pi();

	// variable to fill QA container
	Float_t xQA[5] = {static_cast<Float_t>(iC),static_cast<Float_t>(aodTrack->Pt()), 0.0,deltaPhiV0,x[4]}; // v2
	Float_t xQA3[5] = {static_cast<Float_t>(iC),static_cast<Float_t>(aodTrack->Pt()), 0.0,deltaPhiV0v3,x[4]}; // v3

	// extra QA TProfiles
	if(iV0==1 && aodTrack->Pt() < 20 && fPID->GetCurrentMask(0) && fPID->GetCurrentMask(1)){
	  Float_t xQApid[2] = {static_cast<Float_t>(iC),static_cast<Float_t>(aodTrack->Pt())};
	  fContQApid->Fill(0,nsigmaTPC[2],v2V0,xQApid); // v2 TPC (V0C) w.r.t pions
	  fContQApid->Fill(1,nsigmaTOF[2],v2V0,xQApid); // v2 TOF (V0C) w.r.t. pions
	  fContQApid->Fill(2,nsigmaTPC[3],v2V0,xQApid); // v2 TPC (V0C) w.r.t kaons
	  fContQApid->Fill(3,nsigmaTOF[3],v2V0,xQApid); // v2 TOF (V0C) w.r.t. kaons
	  fContQApid->Fill(4,nsigmaTPC[4],v2V0,xQApid); // v2 TPC (V0C) w.r.t protons
	  fContQApid->Fill(5,nsigmaTOF[4],v2V0,xQApid); // v2 TOF (V0C) w.r.t. protons
	}

	// QA fill
	if(!(fPID->GetCurrentMask(0)) || !aodTrack->GetDetPid() || dedx < 10. || aodTrack->Pt() < 0 || aodTrack->Pt() > 7){}
	else{
	  if(TMath::Abs(nsigmaTPC[2])<5 && (!(fPID->GetCurrentMask(1)) || (TMath::Abs(nsigmaTOF[2])<5))){ //pi
	    xQA[2] = prob[2];
	    xQA3[2] = xQA[2];
	    if(fQAsw && fV2) QA[iV0]->Fill(0,nsigmaTPC[2],nsigmaTOF[2],xQA);
 	    if(fQAsw && fV3) QAv3[iV0]->Fill(0,nsigmaTPC[2],nsigmaTOF[2],xQA3);
	  }
	  if(TMath::Abs(nsigmaTPC[3])<5 && (!(fPID->GetCurrentMask(1)) || (TMath::Abs(nsigmaTOF[3])<5))){ //K
	    xQA[2] = prob[3];
	    xQA3[2] = xQA[2];
	    if(fQAsw && fV2) QA[iV0]->Fill(1,nsigmaTPC[3],nsigmaTOF[3],xQA);
// 	    if(fQAsw && fV3) QAv3[iV0]->Fill(1,nsigmaTPC[3],nsigmaTOF[3],xQA3);	  
	  }
	  if(TMath::Abs(nsigmaTPC[4])<5 && (!(fPID->GetCurrentMask(1)) || (TMath::Abs(nsigmaTOF[4])<5))){//p
	    xQA[2] = prob[4];
	    xQA3[2] = xQA[2];
	    if(fQAsw && fV2) QA[iV0]->Fill(2,nsigmaTPC[4],nsigmaTOF[4],xQA);
// 	    if(fQAsw && fV3) QAv3[iV0]->Fill(2,nsigmaTPC[4],nsigmaTOF[4],xQA3);	  
	  }
	  if(TMath::Abs(nsigmaTPC[0])<5 && (!(fPID->GetCurrentMask(1)) || (TMath::Abs(nsigmaTOF[0])<5))){//e
	    xQA[2] = prob[0];
	    xQA3[2] = xQA[2];
// 	    if(fQAsw && fV2) QA[iV0]->Fill(3,nsigmaTPC[0],nsigmaTOF[0],xQA);
// 	    if(fQAsw && fV3) QAv3[iV0]->Fill(3,nsigmaTPC[0],nsigmaTOF[0],xQA3);	  
	  }
	  if(TMath::Abs(nsigmaTPC[5])<5 && (!(fPID->GetCurrentMask(1)) || (TMath::Abs(nsigmaTOF[5])<5))){//d
	    xQA[2] = prob[5];
	    xQA3[2] = xQA[2];
	    // 	  if(fQAsw && fV2) QA[iV0]->Fill(4,nsigmaTPC[5],nsigmaTOF[5],xQA);
	    // 	  if(fQAsw && fV3) QAv3[iV0]->Fill(4,nsigmaTPC[5],nsigmaTOF[5],xQA3);	  
	  }
	  if(TMath::Abs(nsigmaTPC[6])<5 && (!(fPID->GetCurrentMask(1)) || (TMath::Abs(nsigmaTOF[6])<5))){//t
	    xQA[2] = prob[6];
	    xQA3[2] = xQA[2];
	    // 	  if(fQAsw && fV2) QA[iV0]->Fill(5,nsigmaTPC[6],nsigmaTOF[6],xQA);
	    // 	  if(fQAsw && fV3) QAv3[iV0]->Fill(5,nsigmaTPC[6],nsigmaTOF[6],xQA3);	  
	  }
	  if(TMath::Abs(nsigmaTPC[7])<5 && (!(fPID->GetCurrentMask(1)) || (TMath::Abs(nsigmaTOF[7])<5))){//He3
	    xQA[2] = prob[7];
	    xQA3[2] = xQA[2];
	    // 	  if(fQAsw && fV2) QA[iV0]->Fill(6,nsigmaTPC[7],nsigmaTOF[7],xQA);
	    // 	  if(fQAsw && fV3) QAv3[iV0]->Fill(6,nsigmaTPC[7],nsigmaTOF[7],xQA3);	  
	  }
	}

	//pid selection
	if(!(fPID->GetCurrentMask(0)) || !aodTrack->GetDetPid()){} // TPC PID and PID object strictly required (very important!!!!)
	else if(prob[2] > 0.6){ // pi
	  x[2] = prob[2];
	  x3[2] = x[2];
	  if(TMath::Abs(nsigmaTPC[2]) < 5){ // TPC 5 sigma extra cut to accept the track
	    if(fV2) contV0[iV0]->Fill(1,aodTrack->Pt(),v2V0,x);
	    if(fV3) contV0v3[iV0]->Fill(1,aodTrack->Pt(),v3V0,x3);
	    if(x[2] > 0.9 && x[5] < 3) fHdcaPt[iC][0]->Fill(aodTrack->Pt(),b[0]);
	    else if(x[2] > 0.9 && fIsMC) fHdcaPtSec[iC][0]->Fill(aodTrack->Pt(),b[0]);
	  }
	}
	else if(prob[3] > 0.6){ // K
	  x[2] = prob[3];
	  x3[2] = x[2];
	  if(TMath::Abs(nsigmaTPC[3]) < 5){
	    if(fV2) contV0[iV0]->Fill(2,aodTrack->Pt(),v2V0,x);
	    if(fV3) contV0v3[iV0]->Fill(2,aodTrack->Pt(),v3V0,x3);
	    if(x[2] > 0.9 && x[5] < 3) fHdcaPt[iC][1]->Fill(aodTrack->Pt(),b[0]);
	    else if(x[2] > 0.9 && fIsMC) fHdcaPtSec[iC][1]->Fill(aodTrack->Pt(),b[0]);
	  }
	}
	else if(prob[4] > 0.6){ // p
	  x[2] = prob[4];
	  x3[2] = x[2];
	  if(TMath::Abs(nsigmaTPC[4]) < 5){
	    if(fV2) contV0[iV0]->Fill(3,aodTrack->Pt(),v2V0,x);
	    if(fV3) contV0v3[iV0]->Fill(3,aodTrack->Pt(),v3V0,x3);
	    if(x[2] > 0.9 && x[5] < 3 && x[1] < 0) fHdcaPt[iC][2]->Fill(aodTrack->Pt(),b[0]);
	    else if(x[2] > 0.9 && fIsMC && x[1] < 0) fHdcaPtSec[iC][2]->Fill(aodTrack->Pt(),b[0]);
	  }
	}
	else if(prob[0] > 0.6){ // e
	  x[2] = prob[0];
	  x3[2] = x[2];
	  if(TMath::Abs(nsigmaTPC[0]) < 5){
	    if(fV2) contV0[iV0]->Fill(4,aodTrack->Pt(),v2V0,x);
	    if(fV3) contV0v3[iV0]->Fill(4,aodTrack->Pt(),v3V0,x3);
	    if(x[2] > 0.9 && x[5] < 3) fHdcaPt[iC][3]->Fill(aodTrack->Pt(),b[0]);
	    else if(x[2] > 0.9 && fIsMC) fHdcaPtSec[iC][3]->Fill(aodTrack->Pt(),b[0]);
	  }
	}
	else if(prob[1] > 0.6){ // mu
	  x[2] = prob[1];
	  x3[2] = x[2];
	  if(TMath::Abs(nsigmaTPC[1]) < 5){
	    if(fV2) contV0[iV0]->Fill(8,aodTrack->Pt(),v2V0,x);
	    if(fV3) contV0v3[iV0]->Fill(8,aodTrack->Pt(),v3V0,x3);
	  }
	}
	else if(prob[5] > 0.6){ // d
	  x[2] = prob[5];
	  x3[2] = x[2];
	  if(TMath::Abs(nsigmaTPC[5]) < 5){
	    if(fV2) contV0[iV0]->Fill(5,aodTrack->Pt(),v2V0,x);
	    if(fV3) contV0v3[iV0]->Fill(5,aodTrack->Pt(),v3V0,x3);
	    if(x[2] > 0.9 && x[5] < 3 && x[1] < 0) fHdcaPt[iC][4]->Fill(aodTrack->Pt(),b[0]);
	    else if(x[2] > 0.9 && fIsMC && x[1] < 0) fHdcaPtSec[iC][4]->Fill(aodTrack->Pt(),b[0]);
	  }
	}
	else if(prob[6] > 0.6){ // t
	  x[2] = prob[6];
	  x3[2] = x[2];
	  if(TMath::Abs(nsigmaTPC[6]) < 5){
	    if(fV2) contV0[iV0]->Fill(6,aodTrack->Pt(),v2V0,x);
	    if(fV3) contV0v3[iV0]->Fill(6,aodTrack->Pt(),v3V0,x3);
	    if(x[2] > 0.9 && x[5] < 3 && x[1] < 0) fHdcaPt[iC][5]->Fill(aodTrack->Pt(),b[0]);
	    else if(x[2] > 0.9 && fIsMC && x[1] < 0) fHdcaPtSec[iC][5]->Fill(aodTrack->Pt(),b[0]);
	  }
	}
	else if(prob[7] > 0.6){ // He3
	  x[2] = prob[7];
	  x3[2] = x[2];
	  if(TMath::Abs(nsigmaTPC[7]) < 5){
	    if(fV2) contV0[iV0]->Fill(7,aodTrack->Pt()*2,v2V0,x);
	    if(fV3) contV0v3[iV0]->Fill(7,aodTrack->Pt()*2,v3V0,x3);
	    if(x[2] > 0.9 && x[5] < 3 && x[1] < 0) fHdcaPt[iC][6]->Fill(aodTrack->Pt(),b[0]);
	    else if(x[2] > 0.9 && fIsMC && x[1] < 0) fHdcaPtSec[iC][6]->Fill(aodTrack->Pt(),b[0]);
	  }
	}
	
	if(x[4] > 0.5){ // if TOF was present redo TPC stand alone PID to check the PID in the same acceptance (PID mask = 2)
	  fPID->ResetDetOR(1); // exclude TOF from PID
	  tofMismProb = 0;
	  
	  fPID->ComputeProb(aodTrack,fOutputAOD);
	  dedx = fPID->GetDeDx();//aodTrack->GetTPCsignal();
	  probRead = fPID->GetProb();
	  
	  fPID->SetDetOR(1); // include TOF for PID
	}
	Float_t probTPC[8] = {probRead[0],probRead[1],probRead[2],probRead[3],probRead[4],probRead[5],probRead[6],probRead[7]}; // TPC stand alone prbabilities

	//pid selection TPC S.A. with TOF matching
	x[4]*=2; // set the mask to 2 id TOF is present
	if(x[4]<1 || !(fPID->GetCurrentMask(0)) || !aodTrack->GetDetPid()){} // TPC PID S.A. PID in TOF acceptance
	else if(probTPC[2] > 0.6){ // pi
	  x[2] = probTPC[2];
	  x3[2] = x[2];
	  if(TMath::Abs(nsigmaTPC[2]) < 5){
	    if(fV2) contV0[iV0]->Fill(1,aodTrack->Pt(),v2V0,x);
	    if(fV3) contV0v3[iV0]->Fill(1,aodTrack->Pt(),v3V0,x3);
	  }
	}
	else if(probTPC[3] > 0.6){ // K
	  x[2] = probTPC[3];
	  x3[2] = x[2];
	  if(TMath::Abs(nsigmaTPC[3]) < 5){
	    if(fV2) contV0[iV0]->Fill(2,aodTrack->Pt(),v2V0,x);
	    if(fV3) contV0v3[iV0]->Fill(2,aodTrack->Pt(),v3V0,x3);
	  }
	}
	else if(probTPC[4] > 0.6){ // p
	  x[2] = probTPC[4];
	  x3[2] = x[2];
	  if(TMath::Abs(nsigmaTPC[4]) < 5){
	    if(fV2) contV0[iV0]->Fill(3,aodTrack->Pt(),v2V0,x);
	    if(fV3) contV0v3[iV0]->Fill(3,aodTrack->Pt(),v3V0,x3);
	  }
	}
	else if(probTPC[0] > 0.6){ // e
	  x[2] = probTPC[0];
	  x3[2] = x[2];
	  if(TMath::Abs(nsigmaTPC[0]) < 5){
	    if(fV2) contV0[iV0]->Fill(4,aodTrack->Pt(),v2V0,x);
	    if(fV3) contV0v3[iV0]->Fill(4,aodTrack->Pt(),v3V0,x3);
	  }
	}
	else if(probTPC[1] > 0.6){ // mu
	  x[2] = probTPC[1];
	  x3[2] = x[2];
	  if(TMath::Abs(nsigmaTPC[1]) < 5){
	    if(fV2) contV0[iV0]->Fill(8,aodTrack->Pt(),v2V0,x);
	    if(fV3) contV0v3[iV0]->Fill(8,aodTrack->Pt(),v3V0,x3);
	  }
	}
	else if(probTPC[5] > 0.6){ // d
	  x[2] = probTPC[5];
	  x3[2] = x[2];
	  if(TMath::Abs(nsigmaTPC[5]) < 5){
	    if(fV2) contV0[iV0]->Fill(5,aodTrack->Pt(),v2V0,x);
	    if(fV3) contV0v3[iV0]->Fill(5,aodTrack->Pt(),v3V0,x3);
	  }
	}
	else if(probTPC[6] > 0.6){ // t
	  x[2] = probTPC[6];
	  x3[2] = x[2];
	  if(TMath::Abs(nsigmaTPC[6]) < 5){
	    if(fV2) contV0[iV0]->Fill(6,aodTrack->Pt(),v2V0,x);
	    if(fV3) contV0v3[iV0]->Fill(6,aodTrack->Pt(),v3V0,x3);
	  }
	}
	else if(probTPC[7] > 0.6){ // He3
	  x[2] = probTPC[7];
	  x3[2] = x[2];
	  if(TMath::Abs(nsigmaTPC[7]) < 5){
	    if(fV2) contV0[iV0]->Fill(7,aodTrack->Pt()*2,v2V0,x);
	    if(fV3) contV0v3[iV0]->Fill(7,aodTrack->Pt()*2,v3V0,x3);
	  }
	}
      } // end side loop
    } // end track loop

    // my V0 loop
    for(Int_t imy=0;imy<fNK0s;imy++){
      Float_t evPlAngV0[2] = {evPlAngV0ACor2,evPlAngV0CCor2};
      Float_t evPlAngV0v3[2] = {evPlAngV0ACor3,evPlAngV0CCor3};
      
      AliFlowVZEROResults *contV0[2] = {fContAllChargesV0A,fContAllChargesV0C};	
      AliFlowVZEROResults *contV0v3[2] = {fContAllChargesV0Av3,fContAllChargesV0Cv3};
     
      for(Int_t iV0=0;iV0<2;iV0++){ // loop on A and C side
	Float_t x[6] = {static_cast<Float_t>(iC),-1/*my K0s are negative for convention*/,1,evPlAngV0[iV0],1,0}; // to fill analysis v2 container
	Float_t x3[6] = {static_cast<Float_t>(iC),-1,1,evPlAngV0v3[iV0],1,0}; // to fill analysis v3 container

	Float_t v2V0 = TMath::Cos(2*(fPhiK0s[imy] - evPlAngV0[iV0]));
	Float_t v3V0 = TMath::Cos(3*(fPhiK0s[imy] - evPlAngV0v3[iV0]));
	if(fV2) contV0[iV0]->Fill(9,fPtK0s[imy],v2V0,x);
	if(fV3) contV0v3[iV0]->Fill(9,fPtK0s[imy],v3V0,x3);
      }
    }

    // V0 loop
    Int_t nV0s = fOutputAOD->GetNumberOfV0s();
    AliAODv0 *myV0;
    Double_t /*dQT, dALPHA, dPT,*/ dMASS=0.0;
    for (Int_t i=0; i!=nV0s; ++i) {
      myV0 = (AliAODv0*) fOutputAOD->GetV0(i);
      if(!myV0) continue;
      if(myV0->Pt()<0.1 || TMath::Abs(myV0->Eta()) > fEtaCut) continue; // skipping low momentum
      Int_t pass = PassesAODCuts(myV0,fOutputAOD,0);
      if(pass) {
	dMASS = myV0->MassK0Short();
	pass = 3;
	fHK0sMass2->Fill(myV0->Pt(),dMASS);
      }
      if(TMath::Abs(dMASS-0.497)/0.005 > 3){
	pass = PassesAODCuts(myV0,fOutputAOD,1);
	if(pass) dMASS = myV0->MassLambda();
	if(pass==2) dMASS = myV0->MassAntiLambda();
      }

      if(pass){// 1 lambda, 2 antilambda, 3=K0s
	//dPT=myV0->Pt();
	//dQT=myV0->PtArmV0();
	//dALPHA=myV0->AlphaV0();

	Int_t iPos, iNeg;
	AliAODTrack *iT=(AliAODTrack*) myV0->GetDaughter(0);
	if(iT->Charge()>0) {
	  iPos = 0; iNeg = 1;
	} else {
	  iPos = 1; iNeg = 0;
	}

	// check if one of the daugthers was already used
	if(pass == 3 && TMath::Abs(dMASS-0.497)/0.005 < 1){
	  fHKsPhi->Fill(fZvtx, myV0->Phi());
	}

	if(pass == 1000){ // disable
	  Bool_t used = kFALSE;
	  for(Int_t ii=0;ii<nusedForK0s;ii++){
	    if(myV0->GetDaughter(iNeg) == usedForK0s1[ii] || myV0->GetDaughter(iPos) == usedForK0s2[ii]){
	      used = kTRUE;
	    }
	  }
	  if((!used) && nusedForK0s < 1000){
	    nusedForK0s++;
	    usedForK0s1[nusedForK0s] = (AliAODTrack *) myV0->GetDaughter(iNeg);
	    usedForK0s2[nusedForK0s] = (AliAODTrack *) myV0->GetDaughter(iPos);
 	    printf("accepted\n");
	  }
	  else{
	    dMASS = 0;
	    printf("rejected\n");
	  }
	}

	iT=(AliAODTrack*) myV0->GetDaughter(iPos); // positive
	AliAODTrack *jT=(AliAODTrack*) myV0->GetDaughter(iNeg); // negative

	// re-map the container in an array to do the analysis for V0A and V0C within a loop
	Float_t evPlAngV0[2] = {evPlAngV0ACor2,evPlAngV0CCor2};
	AliFlowVZEROResults *contV0[2] = {fContAllChargesV0A,fContAllChargesV0C};
	
	Float_t evPlAngV0v3[2] = {evPlAngV0ACor3,evPlAngV0CCor3};
	AliFlowVZEROResults *contV0v3[2] = {fContAllChargesV0Av3,fContAllChargesV0Cv3};

	for(Int_t iV0=0;iV0<2;iV0++){ // loop on A and C side
	 
	  if(fModulationDEDx) fPID->SetPsiCorrectionDeDx(evPlAngV0[iV0],evPlRes[iV0*8+iC]); // set the PID dE/dx correction as a function of the v2-EP (resolution is needed)

	  Float_t v2V0 = TMath::Cos(2*(myV0->Phi() - evPlAngV0[iV0]));
	  Float_t v3V0 = TMath::Cos(3*(myV0->Phi() - evPlAngV0v3[iV0]));
	  
	  Float_t deltaphi = myV0->Phi()- evPlAngV0[iV0];
	  if(deltaphi > TMath::Pi()) deltaphi -= 2*TMath::Pi();
	  if(deltaphi < -TMath::Pi()) deltaphi += 2*TMath::Pi();

	  Float_t x[6] = {static_cast<Float_t>(iC),1,1,evPlAngV0[iV0],1,0}; // to fill analysis v2 container
	  Float_t x3[6] = {static_cast<Float_t>(iC),1,1,evPlAngV0v3[iV0],1,0}; // to fill analysis v3 container
	  
	  Float_t decaylength = myV0->DecayLengthXY(fOutputAOD->GetPrimaryVertex());
	  //	  printf("decay length = %f\n",decaylength);

	  if(pass==2){ // anti-lambda charge = -1
	    x[1] = -1;
	    x3[1] = -1;
	  }

	  if(decaylength < fMinDistV0) pass = 0;	  
	  if(decaylength > fMaxDistV0) pass = 0;	  

	  Float_t nsigma = 0;
	  if(pass < 3)
	    nsigma = TMath::Abs(dMASS-1.116)/0.0016;
	  else if(pass == 3)
	    nsigma = TMath::Abs(dMASS-0.497)/0.005;

	  if(nsigma < 1)
	    x[2] = 0.95;
	  else if(nsigma < 2)
	    x[2] = 0.85;
	  else if(nsigma < 3)
	    x[2] = 0.75;
	  else if(nsigma < 4)
	    x[2] = 0.65;
	  else
	    x[2] = 0.5;
	  	    
	  x3[2] = x[2];

	  // Fill Container for lambda and Ks
	  if(fV2 && pass == 3 && x[2] > 0.6){
	    contV0[iV0]->Fill(9,myV0->Pt(),v2V0,x);
	    fHctauPtEP->Fill(myV0->Pt(),deltaphi,decaylength);//ciao
	    if(myV0->Pt() < 1.1 && myV0->Pt() > 0.9) fHctauAt1EP->Fill(decaylength,deltaphi);
	  }
	  if(fV3 && pass == 3 && x[2] > 0.6) contV0v3[iV0]->Fill(9,myV0->Pt(),v3V0,x3);
	  if(fV2 && pass < 3 && x[2] > 0.6) contV0[iV0]->Fill(10,myV0->Pt(),v2V0,x);
	  if(fV3 && pass < 3 && x[2] > 0.6) contV0v3[iV0]->Fill(10,myV0->Pt(),v3V0,x3);

	  if(pass < 3){ // lambda
	    AliAODTrack* aodTrack = iT;
	    if(pass==2) aodTrack=jT;

	    v2V0 = TMath::Cos(2*(aodTrack->Phi() - evPlAngV0[iV0]));
	    v3V0 = TMath::Cos(3*(aodTrack->Phi() - evPlAngV0v3[iV0]));

	    fPID->ComputeProb(aodTrack,fOutputAOD); // compute Bayesian probabilities
	    Float_t *probRead = fPID->GetProb();
	    Float_t prob[8] = {probRead[0],probRead[1],probRead[2],probRead[3],probRead[4],probRead[5],probRead[6],probRead[7]};
	    Float_t tofMismProb = fPID->GetTOFMismProb(); // TOF mismatch probability requested to be lower than 50% for TOF analysis 

            if(prob[4] < 0.61) prob[4] = 0.61;
	    
	    Float_t xdec[6] = {static_cast<Float_t>(iC),static_cast<Float_t>(aodTrack->Charge()),prob[4],evPlAngV0[iV0],static_cast<Float_t>(fPID->GetCurrentMask(1)&&tofMismProb < 0.5),0}; // to fill analysis v2 container
	    Float_t xdec3[6] = {static_cast<Float_t>(iC),static_cast<Float_t>(aodTrack->Charge()),prob[4],evPlAngV0v3[iV0],static_cast<Float_t>(fPID->GetCurrentMask(1)&&tofMismProb < 0.5),0}; // to fill analysis v3 container

	    // Fill Container for (anti)proton from lambda
	    if(nsigma < 2 && xdec[2] > 0.6 && TMath::Abs(aodTrack->Eta()) < 0.8){
	      if(fV2) contV0[iV0]->Fill(11,aodTrack->Pt(),v2V0,xdec);
	      if(fV3) contV0v3[iV0]->Fill(11,aodTrack->Pt(),v3V0,xdec3);
	    }
	  }
          else if(pass == 3){
            AliAODTrack* aodTrack = iT;

            v2V0 = TMath::Cos(2*(aodTrack->Phi() - evPlAngV0[iV0]));
            v3V0 = TMath::Cos(3*(aodTrack->Phi() - evPlAngV0v3[iV0]));

            fPID->ComputeProb(aodTrack,fOutputAOD); // compute Bayesian probabilities
            Float_t *probRead = fPID->GetProb();
            Float_t prob[8] = {probRead[0],probRead[1],probRead[2],probRead[3],probRead[4],probRead[5],probRead[6],probRead[7]};
            Float_t tofMismProb = fPID->GetTOFMismProb(); // TOF mismatch probability requested to be lower than 50% for TOF analysis

            if(prob[2] < 0.61) prob[2] = 0.61;

            Float_t xdec[6] = {static_cast<Float_t>(iC),static_cast<Float_t>(aodTrack->Charge()),prob[2],evPlAngV0[iV0],static_cast<Float_t>(fPID->GetCurrentMask(1)&&tofMismProb < 0.5),0}; // to 
            Float_t xdec3[6] = {static_cast<Float_t>(iC),static_cast<Float_t>(aodTrack->Charge()),prob[2],evPlAngV0v3[iV0],static_cast<Float_t>(fPID->GetCurrentMask(1)&&tofMismProb < 0.5),0}; // to 

            if(nsigma < 2 && xdec[2] > 0.6 && TMath::Abs(aodTrack->Eta()) < 0.8){
              if(fV2) contV0[iV0]->Fill(12,aodTrack->Pt(),v2V0,xdec);
              if(fV3) contV0v3[iV0]->Fill(12,aodTrack->Pt(),v3V0,xdec3);
            }
           
            aodTrack = jT;
            v2V0 = TMath::Cos(2*(aodTrack->Phi() - evPlAngV0[iV0]));
            v3V0 = TMath::Cos(3*(aodTrack->Phi() - evPlAngV0v3[iV0]));

            fPID->ComputeProb(aodTrack,fOutputAOD); // compute Bayesian probabilities
            Float_t *probRead2 = fPID->GetProb();
            Float_t prob2[8] = {probRead2[0],probRead2[1],probRead2[2],probRead2[3],probRead2[4],probRead2[5],probRead2[6],probRead2[7]};
            Float_t tofMismProb2 = fPID->GetTOFMismProb(); // TOF mismatch probability requested to be lower than 50% for TOF analysis

            if(prob2[2] < 0.61) prob2[2] = 0.61;

            Float_t xdecB[6] = {static_cast<Float_t>(iC),static_cast<Float_t>(aodTrack->Charge()),prob2[2],evPlAngV0[iV0],static_cast<Float_t>(fPID->GetCurrentMask(1)&&tofMismProb2 < 0.5),0}; // to
            Float_t xdecB3[6] = {static_cast<Float_t>(iC),static_cast<Float_t>(aodTrack->Charge()),prob2[2],evPlAngV0v3[iV0],static_cast<Float_t>(fPID->GetCurrentMask(1)&&tofMismProb2 < 0.5),0}; // to

            if(nsigma < 2 && xdecB[2] > 0.6  && TMath::Abs(aodTrack->Eta()) < 0.8){
              if(fV2) contV0[iV0]->Fill(12,aodTrack->Pt(),v2V0,xdecB);
              if(fV3) contV0v3[iV0]->Fill(12,aodTrack->Pt(),v3V0,xdecB3);
            }
          }
	}
	
      }
    } // end loop on V0


    // Fill EP distribution histograms
    if(fV2) fPhiRPv0A->Fill(iC,evPlAngV0ACor2);
    if(fV2) fPhiRPv0C->Fill(iC,evPlAngV0CCor2);
    
    if(fV3) fPhiRPv0Av3->Fill(iC,evPlAngV0ACor3);
    if(fV3) fPhiRPv0Cv3->Fill(iC,evPlAngV0CCor3);

    // Fill histograms needed for resolution evaluation
    if(fV2) fHResTPCv0A2->Fill(Double_t(iC), TMath::Cos(2*(evPlAng2 - evPlAngV0ACor2)));
    if(fV2) fHResTPCv0C2->Fill(Double_t(iC), TMath::Cos(2*(evPlAng2 - evPlAngV0CCor2)));
    if(fV2) fHResv0Cv0A2->Fill(Double_t(iC), TMath::Cos(2*(evPlAngV0ACor2 - evPlAngV0CCor2)));
    
    if(fV3) fHResTPCv0A3->Fill(Double_t(iC), TMath::Cos(3*(evPlAng3 - evPlAngV0ACor3)));
    if(fV3) fHResTPCv0C3->Fill(Double_t(iC), TMath::Cos(3*(evPlAng3 - evPlAngV0CCor3)));
    if(fV3) fHResv0Cv0A3->Fill(Double_t(iC), TMath::Cos(3*(evPlAngV0ACor3 - evPlAngV0CCor3)));
  }
  


  // clean track array
  for(Int_t i=0;i < nusedForK0s;i++){
    usedForK0s1[i] = NULL;
    usedForK0s2[i] = NULL;
  }
}

//_____________________________________________________________________________
Float_t AliAnalysisTaskVnV0::GetVertex(AliAODEvent* aod) const
{

  Float_t zvtx = -999;

  const AliAODVertex* vtxAOD = aod->GetPrimaryVertex();
  if (!vtxAOD)
    return zvtx;
  if(vtxAOD->GetNContributors()>0)
    zvtx = vtxAOD->GetZ();
  
  return zvtx;
}
//_____________________________________________________________________________
void AliAnalysisTaskVnV0::Terminate(Option_t *)
{ 
  // Terminate loop
  Printf("Terminate()");
}
//_____________________________________________________________________________
void AliAnalysisTaskVnV0::OpenInfoCalbration(Int_t run){
    TString oadbfilename = "$ALICE_ROOT/OADB/PWGCF/VZERO/VZEROcalibEP.root";
    TFile *foadb = TFile::Open(oadbfilename.Data());

    if(!foadb){
	printf("OADB file %s cannot be opened\n",oadbfilename.Data());
	return;
    }

    AliOADBContainer *cont = (AliOADBContainer*) foadb->Get("hMultV0BefCorr");
    if(!cont){
	printf("OADB object hMultV0BefCorr is not available in the file\n");
	return;	
    }

    if(!(cont->GetObject(run))){
	printf("OADB object hMultV0BefCorr is not available for run %i (used run 137366)\n",run);
	run = 137366;
    }
    fMultV0 = ((TH2F *) cont->GetObject(run))->ProfileX();

    TF1 *fpol0 = new TF1("fpol0","pol0"); 
    fMultV0->Fit(fpol0,"","",0,31);
    fV0Cpol = fpol0->GetParameter(0);
    fMultV0->Fit(fpol0,"","",32,64);
    fV0Apol = fpol0->GetParameter(0);

    for(Int_t iside=0;iside<2;iside++){
	for(Int_t icoord=0;icoord<2;icoord++){
	    for(Int_t i=0;i  < 9;i++){
		char namecont[100];
  		if(iside==0 && icoord==0)
		  snprintf(namecont,100,"hQxc2_%i",i);
		else if(iside==1 && icoord==0)
		  snprintf(namecont,100,"hQxa2_%i",i);
		else if(iside==0 && icoord==1)
		  snprintf(namecont,100,"hQyc2_%i",i);
		else if(iside==1 && icoord==1)
		  snprintf(namecont,100,"hQya2_%i",i);

		cont = (AliOADBContainer*) foadb->Get(namecont);
		if(!cont){
		    printf("OADB object %s is not available in the file\n",namecont);
		    return;	
		}
		
		if(!(cont->GetObject(run))){
		    printf("OADB object %s is not available for run %i (used run 137366)\n",namecont,run);
		    run = 137366;
		}
		fMeanQ[i][iside][icoord] = ((TH1F *) cont->GetObject(run))->GetMean();
		fWidthQ[i][iside][icoord] = ((TH1F *) cont->GetObject(run))->GetRMS();

		//for v3
		if(iside==0 && icoord==0)
		  snprintf(namecont,100,"hQxc3_%i",i);
		else if(iside==1 && icoord==0)
		  snprintf(namecont,100,"hQxa3_%i",i);
		else if(iside==0 && icoord==1)
		  snprintf(namecont,100,"hQyc3_%i",i);
		else if(iside==1 && icoord==1)
		  snprintf(namecont,100,"hQya3_%i",i);

		cont = (AliOADBContainer*) foadb->Get(namecont);
		if(!cont){
		    printf("OADB object %s is not available in the file\n",namecont);
		    return;	
		}
		
		if(!(cont->GetObject(run))){
		    printf("OADB object %s is not available for run %i (used run 137366)\n",namecont,run);
		    run = 137366;
		}
		fMeanQv3[i][iside][icoord] = ((TH1F *) cont->GetObject(run))->GetMean();
		fWidthQv3[i][iside][icoord] = ((TH1F *) cont->GetObject(run))->GetRMS();

     	    }
	}
    }
}
//=======================================================================
Int_t AliAnalysisTaskVnV0::PassesAODCuts(AliAODv0 *myV0, AliAODEvent *tAOD,Int_t specie)
{
  Int_t set = 0;
  Float_t fV0Cuts[9];
  // defines cuts to be used
  // fV0Cuts[9] dl dca ctp d0 d0d0 qt minEta maxEta PID
  switch(set) {
  case(0): // No cuts
    fV0Cuts[0] = -1e+6; fV0Cuts[1] = +1e+6; fV0Cuts[2] = -1e+6;
    fV0Cuts[3] = -1e+6; fV0Cuts[4] = +1e+6; fV0Cuts[5] = -1e+6;
    fV0Cuts[6] = -1e+6; fV0Cuts[7] = +1e+6; fV0Cuts[8] = 0;
    break;
  case(1): // Tight cuts
    fV0Cuts[0] = +0.5; fV0Cuts[1] = +0.5; fV0Cuts[2] = +0.998;
    fV0Cuts[3] = +0.1; fV0Cuts[4] = +0.0; fV0Cuts[5] = +0.105;
    fV0Cuts[6] = -0.8; fV0Cuts[7] = +0.8; fV0Cuts[8] = 0;
    break;
  case(2): // Tight cuts + PID
    fV0Cuts[0] = +0.5; fV0Cuts[1] = +0.5; fV0Cuts[2] = +0.998;
    fV0Cuts[3] = +0.1; fV0Cuts[4] = +0.0; fV0Cuts[5] = +0.105;
    fV0Cuts[6] = -0.8; fV0Cuts[7] = +0.8; fV0Cuts[8] = 1;
    break;
  case(3): // No cuts + PID
    fV0Cuts[0] = -1e+6; fV0Cuts[1] = +1e+6; fV0Cuts[2] = -1e+6;
    fV0Cuts[3] = -1e+6; fV0Cuts[4] = +1e+6; fV0Cuts[5] = -1e+6;
    fV0Cuts[6] = -1e+6; fV0Cuts[7] = +1e+6; fV0Cuts[8] = 1;
    break;
  }

  // daughter cuts
  if(! fCutsDaughter){
    fCutsDaughter = new AliESDtrackCuts(Form("daughter_cuts_%s","ESD") );
    fCutsDaughter->SetPtRange(0.2,10.0);
    fCutsDaughter->SetEtaRange(-0.8, 0.8 );
    fCutsDaughter->SetMinNClustersTPC(80);
    fCutsDaughter->SetMaxChi2PerClusterTPC(4.0);
    fCutsDaughter->SetRequireTPCRefit(kTRUE);
    fCutsDaughter->SetAcceptKinkDaughters(kFALSE);
  }

  if (myV0->GetOnFlyStatus() ) return 0;
  //the following is needed in order to evualuate track-quality
  AliAODTrack *iT, *jT;
  AliAODVertex *vV0s = myV0->GetSecondaryVtx();
  Double_t pos[3],cov[6];
  vV0s->GetXYZ(pos);
  vV0s->GetCovarianceMatrix(cov);
  const AliESDVertex vESD(pos,cov,100.,100);
  // TESTING CHARGE
  int iPos, iNeg;
  iT=(AliAODTrack*) myV0->GetDaughter(0);
  if(iT->Charge()>0) {
    iPos = 0; iNeg = 1;
  } else {
    iPos = 1; iNeg = 0;
  }
  // END OF TEST

  iT=(AliAODTrack*) myV0->GetDaughter(iPos); // positive
  AliESDtrack ieT( iT );
  ieT.SetTPCClusterMap( iT->GetTPCClusterMap() );
  ieT.SetTPCSharedMap( iT->GetTPCSharedMap() );
  ieT.SetTPCPointsF( iT->GetTPCNclsF() );
  ieT.RelateToVertex(&vESD, tAOD->GetMagneticField(), 100);
  if (!fCutsDaughter->IsSelected( &ieT ) ) return 0;

  jT=(AliAODTrack*) myV0->GetDaughter(iNeg); // negative
  AliESDtrack jeT( jT );
  jeT.SetTPCClusterMap( jT->GetTPCClusterMap() );
  jeT.SetTPCSharedMap( jT->GetTPCSharedMap() );
  jeT.SetTPCPointsF( jT->GetTPCNclsF() );
  jeT.RelateToVertex(&vESD, tAOD->GetMagneticField(), 100);
  if (!fCutsDaughter->IsSelected( &jeT ) ) return 0;

  Double_t pvertex[3];
  pvertex[0]=tAOD->GetPrimaryVertex()->GetX();
  pvertex[1]=tAOD->GetPrimaryVertex()->GetY();
  pvertex[2]=tAOD->GetPrimaryVertex()->GetZ();
  Double_t dDL=myV0->DecayLengthV0( pvertex );
  Double_t dDCA=myV0->DcaV0Daughters();
  Double_t dCTP=myV0->CosPointingAngle( pvertex );
  Double_t dD0P=ieT.GetD(pvertex[0],pvertex[1],tAOD->GetMagneticField());
  Double_t dD0M=jeT.GetD(pvertex[0],pvertex[1],tAOD->GetMagneticField());
  Double_t dD0D0=dD0P*dD0M;
  Double_t dQT=myV0->PtArmV0();
  Double_t dALPHA=myV0->AlphaV0(); // AlphaV0 -> AODRecoDecat::Alpha -> return 1.-2./(1.+QlProng(0)/QlProng(1));
  if(myV0->ChargeProng(iPos)<0) dALPHA = -dALPHA; // protects for a change in convention
//   Double_t dPT=myV0->Pt();
  Double_t dETA=myV0->Eta();
  Int_t passes = 1;
  if(dDL  <fV0Cuts[0]) passes = 0;
  if(dDCA >fV0Cuts[1]) passes = 0;
  if(dCTP <fV0Cuts[2]) passes = 0;
  if(TMath::Abs(dD0P) <fV0Cuts[3]) passes = 0;
  if(TMath::Abs(dD0M) <fV0Cuts[3]) passes = 0;
  if(dD0D0>fV0Cuts[4]) passes = 0;
  if(dETA <fV0Cuts[6]) passes = 0;
  if(dETA >fV0Cuts[7]) passes = 0;
  if(specie==0) if(dQT<fV0Cuts[5]) passes = 0;
  if(specie==1&&passes==1&&dALPHA<0) passes = 2; // antilambda


//   if(jT->Pt() < 0.5*myV0->Pt() || iT->Pt() < 0.5*myV0->Pt()) passes = 0;


  // additional cut
//   if(!(iT->GetStatus() & AliAODTrack::kTPCrefit)) passes = 0;
//   if(!(jT->GetStatus() & AliAODTrack::kTPCrefit)) passes = 0;

//   if(!(iT->GetStatus() & AliAODTrack::kITSrefit)) passes = 0;
//   if(!(jT->GetStatus() & AliAODTrack::kITSrefit)) passes = 0;

//  if(!(iT->GetStatus() & AliAODTrack::kTOFout)) passes = 0;
//  if(!(jT->GetStatus() & AliAODTrack::kTOFout)) passes = 0;

  Bool_t trkFlag = iT->TestFilterBit(1); // TPC only tracks (4,global track)
  Bool_t trkFlag2 = jT->TestFilterBit(1); // TPC only tracks (4,global track)

  if(!trkFlag) passes = 0;
  if(!trkFlag2) passes = 0;

  if(passes&&fV0Cuts[8]) {

    Double_t dedxExp[8];
    fPID->ComputeProb(iT,tAOD); // compute Bayesian probabilities
    Float_t nsigmaTPC[8];

//    Int_t tofMatch=0;
//    Int_t tofMatch2=0;

    if(iT->GetDetPid()){ // check the PID object is available
      for(Int_t iS=0;iS < 8;iS++){
	dedxExp[iS] = fPID->GetExpDeDx(iT,iS);
	nsigmaTPC[iS] = (fPID->GetDeDx() - dedxExp[iS])/(dedxExp[iS]*0.07);
      }
    }
    else{
      for(Int_t iS=0;iS < 8;iS++)
	nsigmaTPC[iS] = 10;
    }


//    if(fPID->GetCurrentMask(1)) // if TOF is present
//      tofMatch = 1;

//     Float_t tofMismProbMC = fPID->GetTOFMismProb(); // TOF mismatch probability requested to be lower than 50% for TOF analysis 

    Float_t *probRead = fPID->GetProb();
    Float_t prob[8] = {probRead[0],probRead[1],probRead[2],probRead[3],probRead[4],probRead[5],probRead[6],probRead[7]};

    fPID->ComputeProb(jT,tAOD); // compute Bayesian probabilities
    Float_t nsigmaTPC2[8];
    if(jT->GetDetPid()){ // check the PID object is available
      for(Int_t iS=0;iS < 8;iS++){
	dedxExp[iS] = fPID->GetExpDeDx(jT,iS);
	nsigmaTPC2[iS] = (fPID->GetDeDx() - dedxExp[iS])/(dedxExp[iS]*0.07);
      }
    }
    else{
      for(Int_t iS=0;iS < 8;iS++)
	nsigmaTPC2[iS] = 10;
    }

//    if(fPID->GetCurrentMask(1)) // if TOF is present
//      tofMatch2 = 1;

//     Float_t tofMismProbMC2 = fPID->GetTOFMismProb(); // TOF mismatch probability requested to be lower than 50% for TOF analysis 

    probRead = fPID->GetProb();
    Float_t prob2[8] = {probRead[0],probRead[1],probRead[2],probRead[3],probRead[4],probRead[5],probRead[6],probRead[7]};
    
    if(jT->GetTPCNcls() < fNcluster) passes = 0;
    else if(iT->GetTPCNcls() < fNcluster) passes = 0;

//     if(! (tofMatch && tofMatch2)) passes = 0; 

    /*
    Float_t dMASS = myV0->MassK0Short();
    Float_t nsigmaMass = TMath::Abs(dMASS-0.497)/0.005;
    if(specie == 0 && TMath::Abs(nsigmaMass) < 1 && myV0->Pt() > 1) printf("candidate i=(pt=%f-phi=%f-tof=%i) j=(pt=%f-phi=%f-tof=%i) \n",iT->Pt(),iT->Phi(),tofMatch,jT->Pt(),jT->Phi(),tofMatch2);
    */

    switch(specie) {
    case 0: // K0 PID
      if(0){
	if( ((jT->GetTPCmomentum()<15) &&
	     (TMath::Abs(nsigmaTPC2[2])>3.)) || prob2[2] < 0.9)
	  passes = 0;
	if( ((iT->GetTPCmomentum()<15) &&
	     (TMath::Abs(nsigmaTPC[2])>3.))|| prob[2] < 0.9 )
	  passes = 0;
      }
      break;
    case 1: // Lambda PID  i==pos j ==neg
      if(passes==1) {
	if( (iT->GetTPCmomentum()<15) &&
	    (TMath::Abs(nsigmaTPC[4])>3.) )
	  passes = 0;
	if( (jT->GetTPCmomentum()<15) &&
	    (TMath::Abs(nsigmaTPC2[2])>3.) )
	  passes = 0;
      }
      if(passes==2) {
	if( (iT->GetTPCmomentum()<15) &&
	    (TMath::Abs(nsigmaTPC[2])>3.) )
	  passes = 0;
	if( (jT->GetTPCmomentum()<15) &&
	    (TMath::Abs(nsigmaTPC2[4])>3.) )
	  passes = 0;
      }
      break;
    }
  }
  return passes;
}
//=======================================================================
void AliAnalysisTaskVnV0::SelectK0s(){
  fNK0s=0;
  fNpiPos=0;
  fNpiNeg=0;

  if(fModulationDEDx) fPID->SetPsiCorrectionDeDx(evPlAng2,1.0); // set the PID dE/dx correction as a function of the v2-EP (resolution is needed)

  // fill pion stacks
  Int_t nAODTracks = fOutputAOD->GetNumberOfTracks();
  for(Int_t iT = 0; iT < nAODTracks; iT++) { // loop on the tracks
    AliAODTrack* aodTrack = dynamic_cast<AliAODTrack*>(fOutputAOD->GetTrack(iT));
    if(!aodTrack) AliFatal("Not a standard AOD");
    
    if (!aodTrack){
      continue;
    }
    
    Bool_t trkFlag = aodTrack->TestFilterBit(1); // TPC only tracks
//    trkFlag = aodTrack->TestFilterBit(4); // Global track, DCA loose cut

    if ((TMath::Abs(aodTrack->Eta()) > fEtaCut) || (aodTrack->Pt() < fMinPt) || (aodTrack->GetTPCNcls() < fNcluster) || !trkFlag){
      continue;
    }

    Double_t b[2] = {-99., -99.};
    Double_t bCov[3] = {-99., -99., -99.};

    AliAODTrack param(*aodTrack);
    if (!param.PropagateToDCA(fOutputAOD->GetPrimaryVertex(), fOutputAOD->GetMagneticField(), 100., b, bCov)){
      continue;
    }

    if(TMath::Abs(b[0]) < 0.5/aodTrack->Pt()) continue;

    fPID->ComputeProb(aodTrack,fOutputAOD); // compute Bayesian probabilities
    Float_t *probRead = fPID->GetProb();
    Float_t prob[8] = {probRead[0],probRead[1],probRead[2],probRead[3],probRead[4],probRead[5],probRead[6],probRead[7]};
 //    Float_t tofMismProb = fPID->GetTOFMismProb(); // TOF mismatch probability requested to be lower than 50% for TOF analysis 

    Int_t charge = aodTrack->Charge();
    if(prob[2] > 0.9){
      if(charge > 0){
	fIPiPos[fNpiPos] = iT;
	fNpiPos++;
      }
      else{
	fIPiNeg[fNpiNeg] = iT;
	fNpiNeg++;
      }	    
    }
  }

  for(Int_t i=0;i < fNpiPos;i++){
    AliAODTrack *pip = dynamic_cast<AliAODTrack*>(fOutputAOD->GetTrack(fIPiPos[i]));
    if(!pip) AliFatal("Not a standard AOD");
    AliESDtrack pipE(pip);

    for(Int_t j=0;j < fNpiNeg;j++){
      AliAODTrack *pin = dynamic_cast<AliAODTrack*>(fOutputAOD->GetTrack(fIPiNeg[j]));
      if(!pin) AliFatal("Not a standard AOD");
      AliESDtrack pinE(pin);

      Double_t xn, xp, mindist=pinE.GetDCA(&pipE,fOutputAOD->GetMagneticField(),xn,xp);

      Double_t pPos[3];
      Double_t pNeg[3];
      pipE.GetPxPyPzAt(xp,fOutputAOD->GetMagneticField(),pPos);
      pinE.GetPxPyPzAt(xn,fOutputAOD->GetMagneticField(),pNeg);

      Float_t length = (xp+xn)*0.5;

      Float_t pxs = pPos[0] + pNeg[0];
      Float_t pys = pPos[1] + pNeg[1];
      Float_t pzs = pPos[2] + pNeg[2];
      Float_t es = TMath::Sqrt(pPos[0]*pPos[0] + pPos[1]*pPos[1] + pPos[2]*pPos[2] + 0.13957*0.13957) + TMath::Sqrt(pNeg[0]*pNeg[0] + pNeg[1]*pNeg[1] + pNeg[2]*pNeg[2] + 0.13957*0.13957);

      Float_t pt = TMath::Sqrt(pxs*pxs + pys*pys);
      Float_t phi = TMath::ATan2(pys,pxs);
      Float_t mass = TMath::Sqrt(es*es - pt*pt - pzs*pzs);
      
      //      if(length > 1) printf("length = %f - distance = %f - mass= %f\n",length,mindist,mass);

      if(mindist < 0.2&& length > 1 && length < 25){
	fHK0sMass->Fill(pt,mass);
	
	Float_t esL = TMath::Sqrt(pPos[0]*pPos[0] + pPos[1]*pPos[1] + pPos[2]*pPos[2] + 0.938*0.938) + TMath::Sqrt(pNeg[0]*pNeg[0] + pNeg[1]*pNeg[1] + pNeg[2]*pNeg[2] + 0.13957*0.13957);
	Float_t esAL = TMath::Sqrt(pPos[0]*pPos[0] + pPos[1]*pPos[1] + pPos[2]*pPos[2] + 0.13957*0.13957) + TMath::Sqrt(pNeg[0]*pNeg[0] + pNeg[1]*pNeg[1] + pNeg[2]*pNeg[2] + 0.938*0.938);

	Float_t massaL = TMath::Sqrt(esL*esL - pt*pt - pzs*pzs);
	Float_t massaAL = TMath::Sqrt(esAL*esAL - pt*pt - pzs*pzs);

	fHK0vsLambda->Fill(mass,TMath::Min(massaL,massaAL));

	if(TMath::Abs(mass-0.497)/0.005 < 1 && massaL > 1.15 && massaAL > 1.15){
	  fPhiK0s[fNK0s] = phi;
	  fPtK0s[fNK0s] = pt;
	  fNK0s++;
	}
      }
    }
  }
}
 AliAnalysisTaskVnV0.cxx:1
 AliAnalysisTaskVnV0.cxx:2
 AliAnalysisTaskVnV0.cxx:3
 AliAnalysisTaskVnV0.cxx:4
 AliAnalysisTaskVnV0.cxx:5
 AliAnalysisTaskVnV0.cxx:6
 AliAnalysisTaskVnV0.cxx:7
 AliAnalysisTaskVnV0.cxx:8
 AliAnalysisTaskVnV0.cxx:9
 AliAnalysisTaskVnV0.cxx:10
 AliAnalysisTaskVnV0.cxx:11
 AliAnalysisTaskVnV0.cxx:12
 AliAnalysisTaskVnV0.cxx:13
 AliAnalysisTaskVnV0.cxx:14
 AliAnalysisTaskVnV0.cxx:15
 AliAnalysisTaskVnV0.cxx:16
 AliAnalysisTaskVnV0.cxx:17
 AliAnalysisTaskVnV0.cxx:18
 AliAnalysisTaskVnV0.cxx:19
 AliAnalysisTaskVnV0.cxx:20
 AliAnalysisTaskVnV0.cxx:21
 AliAnalysisTaskVnV0.cxx:22
 AliAnalysisTaskVnV0.cxx:23
 AliAnalysisTaskVnV0.cxx:24
 AliAnalysisTaskVnV0.cxx:25
 AliAnalysisTaskVnV0.cxx:26
 AliAnalysisTaskVnV0.cxx:27
 AliAnalysisTaskVnV0.cxx:28
 AliAnalysisTaskVnV0.cxx:29
 AliAnalysisTaskVnV0.cxx:30
 AliAnalysisTaskVnV0.cxx:31
 AliAnalysisTaskVnV0.cxx:32
 AliAnalysisTaskVnV0.cxx:33
 AliAnalysisTaskVnV0.cxx:34
 AliAnalysisTaskVnV0.cxx:35
 AliAnalysisTaskVnV0.cxx:36
 AliAnalysisTaskVnV0.cxx:37
 AliAnalysisTaskVnV0.cxx:38
 AliAnalysisTaskVnV0.cxx:39
 AliAnalysisTaskVnV0.cxx:40
 AliAnalysisTaskVnV0.cxx:41
 AliAnalysisTaskVnV0.cxx:42
 AliAnalysisTaskVnV0.cxx:43
 AliAnalysisTaskVnV0.cxx:44
 AliAnalysisTaskVnV0.cxx:45
 AliAnalysisTaskVnV0.cxx:46
 AliAnalysisTaskVnV0.cxx:47
 AliAnalysisTaskVnV0.cxx:48
 AliAnalysisTaskVnV0.cxx:49
 AliAnalysisTaskVnV0.cxx:50
 AliAnalysisTaskVnV0.cxx:51
 AliAnalysisTaskVnV0.cxx:52
 AliAnalysisTaskVnV0.cxx:53
 AliAnalysisTaskVnV0.cxx:54
 AliAnalysisTaskVnV0.cxx:55
 AliAnalysisTaskVnV0.cxx:56
 AliAnalysisTaskVnV0.cxx:57
 AliAnalysisTaskVnV0.cxx:58
 AliAnalysisTaskVnV0.cxx:59
 AliAnalysisTaskVnV0.cxx:60
 AliAnalysisTaskVnV0.cxx:61
 AliAnalysisTaskVnV0.cxx:62
 AliAnalysisTaskVnV0.cxx:63
 AliAnalysisTaskVnV0.cxx:64
 AliAnalysisTaskVnV0.cxx:65
 AliAnalysisTaskVnV0.cxx:66
 AliAnalysisTaskVnV0.cxx:67
 AliAnalysisTaskVnV0.cxx:68
 AliAnalysisTaskVnV0.cxx:69
 AliAnalysisTaskVnV0.cxx:70
 AliAnalysisTaskVnV0.cxx:71
 AliAnalysisTaskVnV0.cxx:72
 AliAnalysisTaskVnV0.cxx:73
 AliAnalysisTaskVnV0.cxx:74
 AliAnalysisTaskVnV0.cxx:75
 AliAnalysisTaskVnV0.cxx:76
 AliAnalysisTaskVnV0.cxx:77
 AliAnalysisTaskVnV0.cxx:78
 AliAnalysisTaskVnV0.cxx:79
 AliAnalysisTaskVnV0.cxx:80
 AliAnalysisTaskVnV0.cxx:81
 AliAnalysisTaskVnV0.cxx:82
 AliAnalysisTaskVnV0.cxx:83
 AliAnalysisTaskVnV0.cxx:84
 AliAnalysisTaskVnV0.cxx:85
 AliAnalysisTaskVnV0.cxx:86
 AliAnalysisTaskVnV0.cxx:87
 AliAnalysisTaskVnV0.cxx:88
 AliAnalysisTaskVnV0.cxx:89
 AliAnalysisTaskVnV0.cxx:90
 AliAnalysisTaskVnV0.cxx:91
 AliAnalysisTaskVnV0.cxx:92
 AliAnalysisTaskVnV0.cxx:93
 AliAnalysisTaskVnV0.cxx:94
 AliAnalysisTaskVnV0.cxx:95
 AliAnalysisTaskVnV0.cxx:96
 AliAnalysisTaskVnV0.cxx:97
 AliAnalysisTaskVnV0.cxx:98
 AliAnalysisTaskVnV0.cxx:99
 AliAnalysisTaskVnV0.cxx:100
 AliAnalysisTaskVnV0.cxx:101
 AliAnalysisTaskVnV0.cxx:102
 AliAnalysisTaskVnV0.cxx:103
 AliAnalysisTaskVnV0.cxx:104
 AliAnalysisTaskVnV0.cxx:105
 AliAnalysisTaskVnV0.cxx:106
 AliAnalysisTaskVnV0.cxx:107
 AliAnalysisTaskVnV0.cxx:108
 AliAnalysisTaskVnV0.cxx:109
 AliAnalysisTaskVnV0.cxx:110
 AliAnalysisTaskVnV0.cxx:111
 AliAnalysisTaskVnV0.cxx:112
 AliAnalysisTaskVnV0.cxx:113
 AliAnalysisTaskVnV0.cxx:114
 AliAnalysisTaskVnV0.cxx:115
 AliAnalysisTaskVnV0.cxx:116
 AliAnalysisTaskVnV0.cxx:117
 AliAnalysisTaskVnV0.cxx:118
 AliAnalysisTaskVnV0.cxx:119
 AliAnalysisTaskVnV0.cxx:120
 AliAnalysisTaskVnV0.cxx:121
 AliAnalysisTaskVnV0.cxx:122
 AliAnalysisTaskVnV0.cxx:123
 AliAnalysisTaskVnV0.cxx:124
 AliAnalysisTaskVnV0.cxx:125
 AliAnalysisTaskVnV0.cxx:126
 AliAnalysisTaskVnV0.cxx:127
 AliAnalysisTaskVnV0.cxx:128
 AliAnalysisTaskVnV0.cxx:129
 AliAnalysisTaskVnV0.cxx:130
 AliAnalysisTaskVnV0.cxx:131
 AliAnalysisTaskVnV0.cxx:132
 AliAnalysisTaskVnV0.cxx:133
 AliAnalysisTaskVnV0.cxx:134
 AliAnalysisTaskVnV0.cxx:135
 AliAnalysisTaskVnV0.cxx:136
 AliAnalysisTaskVnV0.cxx:137
 AliAnalysisTaskVnV0.cxx:138
 AliAnalysisTaskVnV0.cxx:139
 AliAnalysisTaskVnV0.cxx:140
 AliAnalysisTaskVnV0.cxx:141
 AliAnalysisTaskVnV0.cxx:142
 AliAnalysisTaskVnV0.cxx:143
 AliAnalysisTaskVnV0.cxx:144
 AliAnalysisTaskVnV0.cxx:145
 AliAnalysisTaskVnV0.cxx:146
 AliAnalysisTaskVnV0.cxx:147
 AliAnalysisTaskVnV0.cxx:148
 AliAnalysisTaskVnV0.cxx:149
 AliAnalysisTaskVnV0.cxx:150
 AliAnalysisTaskVnV0.cxx:151
 AliAnalysisTaskVnV0.cxx:152
 AliAnalysisTaskVnV0.cxx:153
 AliAnalysisTaskVnV0.cxx:154
 AliAnalysisTaskVnV0.cxx:155
 AliAnalysisTaskVnV0.cxx:156
 AliAnalysisTaskVnV0.cxx:157
 AliAnalysisTaskVnV0.cxx:158
 AliAnalysisTaskVnV0.cxx:159
 AliAnalysisTaskVnV0.cxx:160
 AliAnalysisTaskVnV0.cxx:161
 AliAnalysisTaskVnV0.cxx:162
 AliAnalysisTaskVnV0.cxx:163
 AliAnalysisTaskVnV0.cxx:164
 AliAnalysisTaskVnV0.cxx:165
 AliAnalysisTaskVnV0.cxx:166
 AliAnalysisTaskVnV0.cxx:167
 AliAnalysisTaskVnV0.cxx:168
 AliAnalysisTaskVnV0.cxx:169
 AliAnalysisTaskVnV0.cxx:170
 AliAnalysisTaskVnV0.cxx:171
 AliAnalysisTaskVnV0.cxx:172
 AliAnalysisTaskVnV0.cxx:173
 AliAnalysisTaskVnV0.cxx:174
 AliAnalysisTaskVnV0.cxx:175
 AliAnalysisTaskVnV0.cxx:176
 AliAnalysisTaskVnV0.cxx:177
 AliAnalysisTaskVnV0.cxx:178
 AliAnalysisTaskVnV0.cxx:179
 AliAnalysisTaskVnV0.cxx:180
 AliAnalysisTaskVnV0.cxx:181
 AliAnalysisTaskVnV0.cxx:182
 AliAnalysisTaskVnV0.cxx:183
 AliAnalysisTaskVnV0.cxx:184
 AliAnalysisTaskVnV0.cxx:185
 AliAnalysisTaskVnV0.cxx:186
 AliAnalysisTaskVnV0.cxx:187
 AliAnalysisTaskVnV0.cxx:188
 AliAnalysisTaskVnV0.cxx:189
 AliAnalysisTaskVnV0.cxx:190
 AliAnalysisTaskVnV0.cxx:191
 AliAnalysisTaskVnV0.cxx:192
 AliAnalysisTaskVnV0.cxx:193
 AliAnalysisTaskVnV0.cxx:194
 AliAnalysisTaskVnV0.cxx:195
 AliAnalysisTaskVnV0.cxx:196
 AliAnalysisTaskVnV0.cxx:197
 AliAnalysisTaskVnV0.cxx:198
 AliAnalysisTaskVnV0.cxx:199
 AliAnalysisTaskVnV0.cxx:200
 AliAnalysisTaskVnV0.cxx:201
 AliAnalysisTaskVnV0.cxx:202
 AliAnalysisTaskVnV0.cxx:203
 AliAnalysisTaskVnV0.cxx:204
 AliAnalysisTaskVnV0.cxx:205
 AliAnalysisTaskVnV0.cxx:206
 AliAnalysisTaskVnV0.cxx:207
 AliAnalysisTaskVnV0.cxx:208
 AliAnalysisTaskVnV0.cxx:209
 AliAnalysisTaskVnV0.cxx:210
 AliAnalysisTaskVnV0.cxx:211
 AliAnalysisTaskVnV0.cxx:212
 AliAnalysisTaskVnV0.cxx:213
 AliAnalysisTaskVnV0.cxx:214
 AliAnalysisTaskVnV0.cxx:215
 AliAnalysisTaskVnV0.cxx:216
 AliAnalysisTaskVnV0.cxx:217
 AliAnalysisTaskVnV0.cxx:218
 AliAnalysisTaskVnV0.cxx:219
 AliAnalysisTaskVnV0.cxx:220
 AliAnalysisTaskVnV0.cxx:221
 AliAnalysisTaskVnV0.cxx:222
 AliAnalysisTaskVnV0.cxx:223
 AliAnalysisTaskVnV0.cxx:224
 AliAnalysisTaskVnV0.cxx:225
 AliAnalysisTaskVnV0.cxx:226
 AliAnalysisTaskVnV0.cxx:227
 AliAnalysisTaskVnV0.cxx:228
 AliAnalysisTaskVnV0.cxx:229
 AliAnalysisTaskVnV0.cxx:230
 AliAnalysisTaskVnV0.cxx:231
 AliAnalysisTaskVnV0.cxx:232
 AliAnalysisTaskVnV0.cxx:233
 AliAnalysisTaskVnV0.cxx:234
 AliAnalysisTaskVnV0.cxx:235
 AliAnalysisTaskVnV0.cxx:236
 AliAnalysisTaskVnV0.cxx:237
 AliAnalysisTaskVnV0.cxx:238
 AliAnalysisTaskVnV0.cxx:239
 AliAnalysisTaskVnV0.cxx:240
 AliAnalysisTaskVnV0.cxx:241
 AliAnalysisTaskVnV0.cxx:242
 AliAnalysisTaskVnV0.cxx:243
 AliAnalysisTaskVnV0.cxx:244
 AliAnalysisTaskVnV0.cxx:245
 AliAnalysisTaskVnV0.cxx:246
 AliAnalysisTaskVnV0.cxx:247
 AliAnalysisTaskVnV0.cxx:248
 AliAnalysisTaskVnV0.cxx:249
 AliAnalysisTaskVnV0.cxx:250
 AliAnalysisTaskVnV0.cxx:251
 AliAnalysisTaskVnV0.cxx:252
 AliAnalysisTaskVnV0.cxx:253
 AliAnalysisTaskVnV0.cxx:254
 AliAnalysisTaskVnV0.cxx:255
 AliAnalysisTaskVnV0.cxx:256
 AliAnalysisTaskVnV0.cxx:257
 AliAnalysisTaskVnV0.cxx:258
 AliAnalysisTaskVnV0.cxx:259
 AliAnalysisTaskVnV0.cxx:260
 AliAnalysisTaskVnV0.cxx:261
 AliAnalysisTaskVnV0.cxx:262
 AliAnalysisTaskVnV0.cxx:263
 AliAnalysisTaskVnV0.cxx:264
 AliAnalysisTaskVnV0.cxx:265
 AliAnalysisTaskVnV0.cxx:266
 AliAnalysisTaskVnV0.cxx:267
 AliAnalysisTaskVnV0.cxx:268
 AliAnalysisTaskVnV0.cxx:269
 AliAnalysisTaskVnV0.cxx:270
 AliAnalysisTaskVnV0.cxx:271
 AliAnalysisTaskVnV0.cxx:272
 AliAnalysisTaskVnV0.cxx:273
 AliAnalysisTaskVnV0.cxx:274
 AliAnalysisTaskVnV0.cxx:275
 AliAnalysisTaskVnV0.cxx:276
 AliAnalysisTaskVnV0.cxx:277
 AliAnalysisTaskVnV0.cxx:278
 AliAnalysisTaskVnV0.cxx:279
 AliAnalysisTaskVnV0.cxx:280
 AliAnalysisTaskVnV0.cxx:281
 AliAnalysisTaskVnV0.cxx:282
 AliAnalysisTaskVnV0.cxx:283
 AliAnalysisTaskVnV0.cxx:284
 AliAnalysisTaskVnV0.cxx:285
 AliAnalysisTaskVnV0.cxx:286
 AliAnalysisTaskVnV0.cxx:287
 AliAnalysisTaskVnV0.cxx:288
 AliAnalysisTaskVnV0.cxx:289
 AliAnalysisTaskVnV0.cxx:290
 AliAnalysisTaskVnV0.cxx:291
 AliAnalysisTaskVnV0.cxx:292
 AliAnalysisTaskVnV0.cxx:293
 AliAnalysisTaskVnV0.cxx:294
 AliAnalysisTaskVnV0.cxx:295
 AliAnalysisTaskVnV0.cxx:296
 AliAnalysisTaskVnV0.cxx:297
 AliAnalysisTaskVnV0.cxx:298
 AliAnalysisTaskVnV0.cxx:299
 AliAnalysisTaskVnV0.cxx:300
 AliAnalysisTaskVnV0.cxx:301
 AliAnalysisTaskVnV0.cxx:302
 AliAnalysisTaskVnV0.cxx:303
 AliAnalysisTaskVnV0.cxx:304
 AliAnalysisTaskVnV0.cxx:305
 AliAnalysisTaskVnV0.cxx:306
 AliAnalysisTaskVnV0.cxx:307
 AliAnalysisTaskVnV0.cxx:308
 AliAnalysisTaskVnV0.cxx:309
 AliAnalysisTaskVnV0.cxx:310
 AliAnalysisTaskVnV0.cxx:311
 AliAnalysisTaskVnV0.cxx:312
 AliAnalysisTaskVnV0.cxx:313
 AliAnalysisTaskVnV0.cxx:314
 AliAnalysisTaskVnV0.cxx:315
 AliAnalysisTaskVnV0.cxx:316
 AliAnalysisTaskVnV0.cxx:317
 AliAnalysisTaskVnV0.cxx:318
 AliAnalysisTaskVnV0.cxx:319
 AliAnalysisTaskVnV0.cxx:320
 AliAnalysisTaskVnV0.cxx:321
 AliAnalysisTaskVnV0.cxx:322
 AliAnalysisTaskVnV0.cxx:323
 AliAnalysisTaskVnV0.cxx:324
 AliAnalysisTaskVnV0.cxx:325
 AliAnalysisTaskVnV0.cxx:326
 AliAnalysisTaskVnV0.cxx:327
 AliAnalysisTaskVnV0.cxx:328
 AliAnalysisTaskVnV0.cxx:329
 AliAnalysisTaskVnV0.cxx:330
 AliAnalysisTaskVnV0.cxx:331
 AliAnalysisTaskVnV0.cxx:332
 AliAnalysisTaskVnV0.cxx:333
 AliAnalysisTaskVnV0.cxx:334
 AliAnalysisTaskVnV0.cxx:335
 AliAnalysisTaskVnV0.cxx:336
 AliAnalysisTaskVnV0.cxx:337
 AliAnalysisTaskVnV0.cxx:338
 AliAnalysisTaskVnV0.cxx:339
 AliAnalysisTaskVnV0.cxx:340
 AliAnalysisTaskVnV0.cxx:341
 AliAnalysisTaskVnV0.cxx:342
 AliAnalysisTaskVnV0.cxx:343
 AliAnalysisTaskVnV0.cxx:344
 AliAnalysisTaskVnV0.cxx:345
 AliAnalysisTaskVnV0.cxx:346
 AliAnalysisTaskVnV0.cxx:347
 AliAnalysisTaskVnV0.cxx:348
 AliAnalysisTaskVnV0.cxx:349
 AliAnalysisTaskVnV0.cxx:350
 AliAnalysisTaskVnV0.cxx:351
 AliAnalysisTaskVnV0.cxx:352
 AliAnalysisTaskVnV0.cxx:353
 AliAnalysisTaskVnV0.cxx:354
 AliAnalysisTaskVnV0.cxx:355
 AliAnalysisTaskVnV0.cxx:356
 AliAnalysisTaskVnV0.cxx:357
 AliAnalysisTaskVnV0.cxx:358
 AliAnalysisTaskVnV0.cxx:359
 AliAnalysisTaskVnV0.cxx:360
 AliAnalysisTaskVnV0.cxx:361
 AliAnalysisTaskVnV0.cxx:362
 AliAnalysisTaskVnV0.cxx:363
 AliAnalysisTaskVnV0.cxx:364
 AliAnalysisTaskVnV0.cxx:365
 AliAnalysisTaskVnV0.cxx:366
 AliAnalysisTaskVnV0.cxx:367
 AliAnalysisTaskVnV0.cxx:368
 AliAnalysisTaskVnV0.cxx:369
 AliAnalysisTaskVnV0.cxx:370
 AliAnalysisTaskVnV0.cxx:371
 AliAnalysisTaskVnV0.cxx:372
 AliAnalysisTaskVnV0.cxx:373
 AliAnalysisTaskVnV0.cxx:374
 AliAnalysisTaskVnV0.cxx:375
 AliAnalysisTaskVnV0.cxx:376
 AliAnalysisTaskVnV0.cxx:377
 AliAnalysisTaskVnV0.cxx:378
 AliAnalysisTaskVnV0.cxx:379
 AliAnalysisTaskVnV0.cxx:380
 AliAnalysisTaskVnV0.cxx:381
 AliAnalysisTaskVnV0.cxx:382
 AliAnalysisTaskVnV0.cxx:383
 AliAnalysisTaskVnV0.cxx:384
 AliAnalysisTaskVnV0.cxx:385
 AliAnalysisTaskVnV0.cxx:386
 AliAnalysisTaskVnV0.cxx:387
 AliAnalysisTaskVnV0.cxx:388
 AliAnalysisTaskVnV0.cxx:389
 AliAnalysisTaskVnV0.cxx:390
 AliAnalysisTaskVnV0.cxx:391
 AliAnalysisTaskVnV0.cxx:392
 AliAnalysisTaskVnV0.cxx:393
 AliAnalysisTaskVnV0.cxx:394
 AliAnalysisTaskVnV0.cxx:395
 AliAnalysisTaskVnV0.cxx:396
 AliAnalysisTaskVnV0.cxx:397
 AliAnalysisTaskVnV0.cxx:398
 AliAnalysisTaskVnV0.cxx:399
 AliAnalysisTaskVnV0.cxx:400
 AliAnalysisTaskVnV0.cxx:401
 AliAnalysisTaskVnV0.cxx:402
 AliAnalysisTaskVnV0.cxx:403
 AliAnalysisTaskVnV0.cxx:404
 AliAnalysisTaskVnV0.cxx:405
 AliAnalysisTaskVnV0.cxx:406
 AliAnalysisTaskVnV0.cxx:407
 AliAnalysisTaskVnV0.cxx:408
 AliAnalysisTaskVnV0.cxx:409
 AliAnalysisTaskVnV0.cxx:410
 AliAnalysisTaskVnV0.cxx:411
 AliAnalysisTaskVnV0.cxx:412
 AliAnalysisTaskVnV0.cxx:413
 AliAnalysisTaskVnV0.cxx:414
 AliAnalysisTaskVnV0.cxx:415
 AliAnalysisTaskVnV0.cxx:416
 AliAnalysisTaskVnV0.cxx:417
 AliAnalysisTaskVnV0.cxx:418
 AliAnalysisTaskVnV0.cxx:419
 AliAnalysisTaskVnV0.cxx:420
 AliAnalysisTaskVnV0.cxx:421
 AliAnalysisTaskVnV0.cxx:422
 AliAnalysisTaskVnV0.cxx:423
 AliAnalysisTaskVnV0.cxx:424
 AliAnalysisTaskVnV0.cxx:425
 AliAnalysisTaskVnV0.cxx:426
 AliAnalysisTaskVnV0.cxx:427
 AliAnalysisTaskVnV0.cxx:428
 AliAnalysisTaskVnV0.cxx:429
 AliAnalysisTaskVnV0.cxx:430
 AliAnalysisTaskVnV0.cxx:431
 AliAnalysisTaskVnV0.cxx:432
 AliAnalysisTaskVnV0.cxx:433
 AliAnalysisTaskVnV0.cxx:434
 AliAnalysisTaskVnV0.cxx:435
 AliAnalysisTaskVnV0.cxx:436
 AliAnalysisTaskVnV0.cxx:437
 AliAnalysisTaskVnV0.cxx:438
 AliAnalysisTaskVnV0.cxx:439
 AliAnalysisTaskVnV0.cxx:440
 AliAnalysisTaskVnV0.cxx:441
 AliAnalysisTaskVnV0.cxx:442
 AliAnalysisTaskVnV0.cxx:443
 AliAnalysisTaskVnV0.cxx:444
 AliAnalysisTaskVnV0.cxx:445
 AliAnalysisTaskVnV0.cxx:446
 AliAnalysisTaskVnV0.cxx:447
 AliAnalysisTaskVnV0.cxx:448
 AliAnalysisTaskVnV0.cxx:449
 AliAnalysisTaskVnV0.cxx:450
 AliAnalysisTaskVnV0.cxx:451
 AliAnalysisTaskVnV0.cxx:452
 AliAnalysisTaskVnV0.cxx:453
 AliAnalysisTaskVnV0.cxx:454
 AliAnalysisTaskVnV0.cxx:455
 AliAnalysisTaskVnV0.cxx:456
 AliAnalysisTaskVnV0.cxx:457
 AliAnalysisTaskVnV0.cxx:458
 AliAnalysisTaskVnV0.cxx:459
 AliAnalysisTaskVnV0.cxx:460
 AliAnalysisTaskVnV0.cxx:461
 AliAnalysisTaskVnV0.cxx:462
 AliAnalysisTaskVnV0.cxx:463
 AliAnalysisTaskVnV0.cxx:464
 AliAnalysisTaskVnV0.cxx:465
 AliAnalysisTaskVnV0.cxx:466
 AliAnalysisTaskVnV0.cxx:467
 AliAnalysisTaskVnV0.cxx:468
 AliAnalysisTaskVnV0.cxx:469
 AliAnalysisTaskVnV0.cxx:470
 AliAnalysisTaskVnV0.cxx:471
 AliAnalysisTaskVnV0.cxx:472
 AliAnalysisTaskVnV0.cxx:473
 AliAnalysisTaskVnV0.cxx:474
 AliAnalysisTaskVnV0.cxx:475
 AliAnalysisTaskVnV0.cxx:476
 AliAnalysisTaskVnV0.cxx:477
 AliAnalysisTaskVnV0.cxx:478
 AliAnalysisTaskVnV0.cxx:479
 AliAnalysisTaskVnV0.cxx:480
 AliAnalysisTaskVnV0.cxx:481
 AliAnalysisTaskVnV0.cxx:482
 AliAnalysisTaskVnV0.cxx:483
 AliAnalysisTaskVnV0.cxx:484
 AliAnalysisTaskVnV0.cxx:485
 AliAnalysisTaskVnV0.cxx:486
 AliAnalysisTaskVnV0.cxx:487
 AliAnalysisTaskVnV0.cxx:488
 AliAnalysisTaskVnV0.cxx:489
 AliAnalysisTaskVnV0.cxx:490
 AliAnalysisTaskVnV0.cxx:491
 AliAnalysisTaskVnV0.cxx:492
 AliAnalysisTaskVnV0.cxx:493
 AliAnalysisTaskVnV0.cxx:494
 AliAnalysisTaskVnV0.cxx:495
 AliAnalysisTaskVnV0.cxx:496
 AliAnalysisTaskVnV0.cxx:497
 AliAnalysisTaskVnV0.cxx:498
 AliAnalysisTaskVnV0.cxx:499
 AliAnalysisTaskVnV0.cxx:500
 AliAnalysisTaskVnV0.cxx:501
 AliAnalysisTaskVnV0.cxx:502
 AliAnalysisTaskVnV0.cxx:503
 AliAnalysisTaskVnV0.cxx:504
 AliAnalysisTaskVnV0.cxx:505
 AliAnalysisTaskVnV0.cxx:506
 AliAnalysisTaskVnV0.cxx:507
 AliAnalysisTaskVnV0.cxx:508
 AliAnalysisTaskVnV0.cxx:509
 AliAnalysisTaskVnV0.cxx:510
 AliAnalysisTaskVnV0.cxx:511
 AliAnalysisTaskVnV0.cxx:512
 AliAnalysisTaskVnV0.cxx:513
 AliAnalysisTaskVnV0.cxx:514
 AliAnalysisTaskVnV0.cxx:515
 AliAnalysisTaskVnV0.cxx:516
 AliAnalysisTaskVnV0.cxx:517
 AliAnalysisTaskVnV0.cxx:518
 AliAnalysisTaskVnV0.cxx:519
 AliAnalysisTaskVnV0.cxx:520
 AliAnalysisTaskVnV0.cxx:521
 AliAnalysisTaskVnV0.cxx:522
 AliAnalysisTaskVnV0.cxx:523
 AliAnalysisTaskVnV0.cxx:524
 AliAnalysisTaskVnV0.cxx:525
 AliAnalysisTaskVnV0.cxx:526
 AliAnalysisTaskVnV0.cxx:527
 AliAnalysisTaskVnV0.cxx:528
 AliAnalysisTaskVnV0.cxx:529
 AliAnalysisTaskVnV0.cxx:530
 AliAnalysisTaskVnV0.cxx:531
 AliAnalysisTaskVnV0.cxx:532
 AliAnalysisTaskVnV0.cxx:533
 AliAnalysisTaskVnV0.cxx:534
 AliAnalysisTaskVnV0.cxx:535
 AliAnalysisTaskVnV0.cxx:536
 AliAnalysisTaskVnV0.cxx:537
 AliAnalysisTaskVnV0.cxx:538
 AliAnalysisTaskVnV0.cxx:539
 AliAnalysisTaskVnV0.cxx:540
 AliAnalysisTaskVnV0.cxx:541
 AliAnalysisTaskVnV0.cxx:542
 AliAnalysisTaskVnV0.cxx:543
 AliAnalysisTaskVnV0.cxx:544
 AliAnalysisTaskVnV0.cxx:545
 AliAnalysisTaskVnV0.cxx:546
 AliAnalysisTaskVnV0.cxx:547
 AliAnalysisTaskVnV0.cxx:548
 AliAnalysisTaskVnV0.cxx:549
 AliAnalysisTaskVnV0.cxx:550
 AliAnalysisTaskVnV0.cxx:551
 AliAnalysisTaskVnV0.cxx:552
 AliAnalysisTaskVnV0.cxx:553
 AliAnalysisTaskVnV0.cxx:554
 AliAnalysisTaskVnV0.cxx:555
 AliAnalysisTaskVnV0.cxx:556
 AliAnalysisTaskVnV0.cxx:557
 AliAnalysisTaskVnV0.cxx:558
 AliAnalysisTaskVnV0.cxx:559
 AliAnalysisTaskVnV0.cxx:560
 AliAnalysisTaskVnV0.cxx:561
 AliAnalysisTaskVnV0.cxx:562
 AliAnalysisTaskVnV0.cxx:563
 AliAnalysisTaskVnV0.cxx:564
 AliAnalysisTaskVnV0.cxx:565
 AliAnalysisTaskVnV0.cxx:566
 AliAnalysisTaskVnV0.cxx:567
 AliAnalysisTaskVnV0.cxx:568
 AliAnalysisTaskVnV0.cxx:569
 AliAnalysisTaskVnV0.cxx:570
 AliAnalysisTaskVnV0.cxx:571
 AliAnalysisTaskVnV0.cxx:572
 AliAnalysisTaskVnV0.cxx:573
 AliAnalysisTaskVnV0.cxx:574
 AliAnalysisTaskVnV0.cxx:575
 AliAnalysisTaskVnV0.cxx:576
 AliAnalysisTaskVnV0.cxx:577
 AliAnalysisTaskVnV0.cxx:578
 AliAnalysisTaskVnV0.cxx:579
 AliAnalysisTaskVnV0.cxx:580
 AliAnalysisTaskVnV0.cxx:581
 AliAnalysisTaskVnV0.cxx:582
 AliAnalysisTaskVnV0.cxx:583
 AliAnalysisTaskVnV0.cxx:584
 AliAnalysisTaskVnV0.cxx:585
 AliAnalysisTaskVnV0.cxx:586
 AliAnalysisTaskVnV0.cxx:587
 AliAnalysisTaskVnV0.cxx:588
 AliAnalysisTaskVnV0.cxx:589
 AliAnalysisTaskVnV0.cxx:590
 AliAnalysisTaskVnV0.cxx:591
 AliAnalysisTaskVnV0.cxx:592
 AliAnalysisTaskVnV0.cxx:593
 AliAnalysisTaskVnV0.cxx:594
 AliAnalysisTaskVnV0.cxx:595
 AliAnalysisTaskVnV0.cxx:596
 AliAnalysisTaskVnV0.cxx:597
 AliAnalysisTaskVnV0.cxx:598
 AliAnalysisTaskVnV0.cxx:599
 AliAnalysisTaskVnV0.cxx:600
 AliAnalysisTaskVnV0.cxx:601
 AliAnalysisTaskVnV0.cxx:602
 AliAnalysisTaskVnV0.cxx:603
 AliAnalysisTaskVnV0.cxx:604
 AliAnalysisTaskVnV0.cxx:605
 AliAnalysisTaskVnV0.cxx:606
 AliAnalysisTaskVnV0.cxx:607
 AliAnalysisTaskVnV0.cxx:608
 AliAnalysisTaskVnV0.cxx:609
 AliAnalysisTaskVnV0.cxx:610
 AliAnalysisTaskVnV0.cxx:611
 AliAnalysisTaskVnV0.cxx:612
 AliAnalysisTaskVnV0.cxx:613
 AliAnalysisTaskVnV0.cxx:614
 AliAnalysisTaskVnV0.cxx:615
 AliAnalysisTaskVnV0.cxx:616
 AliAnalysisTaskVnV0.cxx:617
 AliAnalysisTaskVnV0.cxx:618
 AliAnalysisTaskVnV0.cxx:619
 AliAnalysisTaskVnV0.cxx:620
 AliAnalysisTaskVnV0.cxx:621
 AliAnalysisTaskVnV0.cxx:622
 AliAnalysisTaskVnV0.cxx:623
 AliAnalysisTaskVnV0.cxx:624
 AliAnalysisTaskVnV0.cxx:625
 AliAnalysisTaskVnV0.cxx:626
 AliAnalysisTaskVnV0.cxx:627
 AliAnalysisTaskVnV0.cxx:628
 AliAnalysisTaskVnV0.cxx:629
 AliAnalysisTaskVnV0.cxx:630
 AliAnalysisTaskVnV0.cxx:631
 AliAnalysisTaskVnV0.cxx:632
 AliAnalysisTaskVnV0.cxx:633
 AliAnalysisTaskVnV0.cxx:634
 AliAnalysisTaskVnV0.cxx:635
 AliAnalysisTaskVnV0.cxx:636
 AliAnalysisTaskVnV0.cxx:637
 AliAnalysisTaskVnV0.cxx:638
 AliAnalysisTaskVnV0.cxx:639
 AliAnalysisTaskVnV0.cxx:640
 AliAnalysisTaskVnV0.cxx:641
 AliAnalysisTaskVnV0.cxx:642
 AliAnalysisTaskVnV0.cxx:643
 AliAnalysisTaskVnV0.cxx:644
 AliAnalysisTaskVnV0.cxx:645
 AliAnalysisTaskVnV0.cxx:646
 AliAnalysisTaskVnV0.cxx:647
 AliAnalysisTaskVnV0.cxx:648
 AliAnalysisTaskVnV0.cxx:649
 AliAnalysisTaskVnV0.cxx:650
 AliAnalysisTaskVnV0.cxx:651
 AliAnalysisTaskVnV0.cxx:652
 AliAnalysisTaskVnV0.cxx:653
 AliAnalysisTaskVnV0.cxx:654
 AliAnalysisTaskVnV0.cxx:655
 AliAnalysisTaskVnV0.cxx:656
 AliAnalysisTaskVnV0.cxx:657
 AliAnalysisTaskVnV0.cxx:658
 AliAnalysisTaskVnV0.cxx:659
 AliAnalysisTaskVnV0.cxx:660
 AliAnalysisTaskVnV0.cxx:661
 AliAnalysisTaskVnV0.cxx:662
 AliAnalysisTaskVnV0.cxx:663
 AliAnalysisTaskVnV0.cxx:664
 AliAnalysisTaskVnV0.cxx:665
 AliAnalysisTaskVnV0.cxx:666
 AliAnalysisTaskVnV0.cxx:667
 AliAnalysisTaskVnV0.cxx:668
 AliAnalysisTaskVnV0.cxx:669
 AliAnalysisTaskVnV0.cxx:670
 AliAnalysisTaskVnV0.cxx:671
 AliAnalysisTaskVnV0.cxx:672
 AliAnalysisTaskVnV0.cxx:673
 AliAnalysisTaskVnV0.cxx:674
 AliAnalysisTaskVnV0.cxx:675
 AliAnalysisTaskVnV0.cxx:676
 AliAnalysisTaskVnV0.cxx:677
 AliAnalysisTaskVnV0.cxx:678
 AliAnalysisTaskVnV0.cxx:679
 AliAnalysisTaskVnV0.cxx:680
 AliAnalysisTaskVnV0.cxx:681
 AliAnalysisTaskVnV0.cxx:682
 AliAnalysisTaskVnV0.cxx:683
 AliAnalysisTaskVnV0.cxx:684
 AliAnalysisTaskVnV0.cxx:685
 AliAnalysisTaskVnV0.cxx:686
 AliAnalysisTaskVnV0.cxx:687
 AliAnalysisTaskVnV0.cxx:688
 AliAnalysisTaskVnV0.cxx:689
 AliAnalysisTaskVnV0.cxx:690
 AliAnalysisTaskVnV0.cxx:691
 AliAnalysisTaskVnV0.cxx:692
 AliAnalysisTaskVnV0.cxx:693
 AliAnalysisTaskVnV0.cxx:694
 AliAnalysisTaskVnV0.cxx:695
 AliAnalysisTaskVnV0.cxx:696
 AliAnalysisTaskVnV0.cxx:697
 AliAnalysisTaskVnV0.cxx:698
 AliAnalysisTaskVnV0.cxx:699
 AliAnalysisTaskVnV0.cxx:700
 AliAnalysisTaskVnV0.cxx:701
 AliAnalysisTaskVnV0.cxx:702
 AliAnalysisTaskVnV0.cxx:703
 AliAnalysisTaskVnV0.cxx:704
 AliAnalysisTaskVnV0.cxx:705
 AliAnalysisTaskVnV0.cxx:706
 AliAnalysisTaskVnV0.cxx:707
 AliAnalysisTaskVnV0.cxx:708
 AliAnalysisTaskVnV0.cxx:709
 AliAnalysisTaskVnV0.cxx:710
 AliAnalysisTaskVnV0.cxx:711
 AliAnalysisTaskVnV0.cxx:712
 AliAnalysisTaskVnV0.cxx:713
 AliAnalysisTaskVnV0.cxx:714
 AliAnalysisTaskVnV0.cxx:715
 AliAnalysisTaskVnV0.cxx:716
 AliAnalysisTaskVnV0.cxx:717
 AliAnalysisTaskVnV0.cxx:718
 AliAnalysisTaskVnV0.cxx:719
 AliAnalysisTaskVnV0.cxx:720
 AliAnalysisTaskVnV0.cxx:721
 AliAnalysisTaskVnV0.cxx:722
 AliAnalysisTaskVnV0.cxx:723
 AliAnalysisTaskVnV0.cxx:724
 AliAnalysisTaskVnV0.cxx:725
 AliAnalysisTaskVnV0.cxx:726
 AliAnalysisTaskVnV0.cxx:727
 AliAnalysisTaskVnV0.cxx:728
 AliAnalysisTaskVnV0.cxx:729
 AliAnalysisTaskVnV0.cxx:730
 AliAnalysisTaskVnV0.cxx:731
 AliAnalysisTaskVnV0.cxx:732
 AliAnalysisTaskVnV0.cxx:733
 AliAnalysisTaskVnV0.cxx:734
 AliAnalysisTaskVnV0.cxx:735
 AliAnalysisTaskVnV0.cxx:736
 AliAnalysisTaskVnV0.cxx:737
 AliAnalysisTaskVnV0.cxx:738
 AliAnalysisTaskVnV0.cxx:739
 AliAnalysisTaskVnV0.cxx:740
 AliAnalysisTaskVnV0.cxx:741
 AliAnalysisTaskVnV0.cxx:742
 AliAnalysisTaskVnV0.cxx:743
 AliAnalysisTaskVnV0.cxx:744
 AliAnalysisTaskVnV0.cxx:745
 AliAnalysisTaskVnV0.cxx:746
 AliAnalysisTaskVnV0.cxx:747
 AliAnalysisTaskVnV0.cxx:748
 AliAnalysisTaskVnV0.cxx:749
 AliAnalysisTaskVnV0.cxx:750
 AliAnalysisTaskVnV0.cxx:751
 AliAnalysisTaskVnV0.cxx:752
 AliAnalysisTaskVnV0.cxx:753
 AliAnalysisTaskVnV0.cxx:754
 AliAnalysisTaskVnV0.cxx:755
 AliAnalysisTaskVnV0.cxx:756
 AliAnalysisTaskVnV0.cxx:757
 AliAnalysisTaskVnV0.cxx:758
 AliAnalysisTaskVnV0.cxx:759
 AliAnalysisTaskVnV0.cxx:760
 AliAnalysisTaskVnV0.cxx:761
 AliAnalysisTaskVnV0.cxx:762
 AliAnalysisTaskVnV0.cxx:763
 AliAnalysisTaskVnV0.cxx:764
 AliAnalysisTaskVnV0.cxx:765
 AliAnalysisTaskVnV0.cxx:766
 AliAnalysisTaskVnV0.cxx:767
 AliAnalysisTaskVnV0.cxx:768
 AliAnalysisTaskVnV0.cxx:769
 AliAnalysisTaskVnV0.cxx:770
 AliAnalysisTaskVnV0.cxx:771
 AliAnalysisTaskVnV0.cxx:772
 AliAnalysisTaskVnV0.cxx:773
 AliAnalysisTaskVnV0.cxx:774
 AliAnalysisTaskVnV0.cxx:775
 AliAnalysisTaskVnV0.cxx:776
 AliAnalysisTaskVnV0.cxx:777
 AliAnalysisTaskVnV0.cxx:778
 AliAnalysisTaskVnV0.cxx:779
 AliAnalysisTaskVnV0.cxx:780
 AliAnalysisTaskVnV0.cxx:781
 AliAnalysisTaskVnV0.cxx:782
 AliAnalysisTaskVnV0.cxx:783
 AliAnalysisTaskVnV0.cxx:784
 AliAnalysisTaskVnV0.cxx:785
 AliAnalysisTaskVnV0.cxx:786
 AliAnalysisTaskVnV0.cxx:787
 AliAnalysisTaskVnV0.cxx:788
 AliAnalysisTaskVnV0.cxx:789
 AliAnalysisTaskVnV0.cxx:790
 AliAnalysisTaskVnV0.cxx:791
 AliAnalysisTaskVnV0.cxx:792
 AliAnalysisTaskVnV0.cxx:793
 AliAnalysisTaskVnV0.cxx:794
 AliAnalysisTaskVnV0.cxx:795
 AliAnalysisTaskVnV0.cxx:796
 AliAnalysisTaskVnV0.cxx:797
 AliAnalysisTaskVnV0.cxx:798
 AliAnalysisTaskVnV0.cxx:799
 AliAnalysisTaskVnV0.cxx:800
 AliAnalysisTaskVnV0.cxx:801
 AliAnalysisTaskVnV0.cxx:802
 AliAnalysisTaskVnV0.cxx:803
 AliAnalysisTaskVnV0.cxx:804
 AliAnalysisTaskVnV0.cxx:805
 AliAnalysisTaskVnV0.cxx:806
 AliAnalysisTaskVnV0.cxx:807
 AliAnalysisTaskVnV0.cxx:808
 AliAnalysisTaskVnV0.cxx:809
 AliAnalysisTaskVnV0.cxx:810
 AliAnalysisTaskVnV0.cxx:811
 AliAnalysisTaskVnV0.cxx:812
 AliAnalysisTaskVnV0.cxx:813
 AliAnalysisTaskVnV0.cxx:814
 AliAnalysisTaskVnV0.cxx:815
 AliAnalysisTaskVnV0.cxx:816
 AliAnalysisTaskVnV0.cxx:817
 AliAnalysisTaskVnV0.cxx:818
 AliAnalysisTaskVnV0.cxx:819
 AliAnalysisTaskVnV0.cxx:820
 AliAnalysisTaskVnV0.cxx:821
 AliAnalysisTaskVnV0.cxx:822
 AliAnalysisTaskVnV0.cxx:823
 AliAnalysisTaskVnV0.cxx:824
 AliAnalysisTaskVnV0.cxx:825
 AliAnalysisTaskVnV0.cxx:826
 AliAnalysisTaskVnV0.cxx:827
 AliAnalysisTaskVnV0.cxx:828
 AliAnalysisTaskVnV0.cxx:829
 AliAnalysisTaskVnV0.cxx:830
 AliAnalysisTaskVnV0.cxx:831
 AliAnalysisTaskVnV0.cxx:832
 AliAnalysisTaskVnV0.cxx:833
 AliAnalysisTaskVnV0.cxx:834
 AliAnalysisTaskVnV0.cxx:835
 AliAnalysisTaskVnV0.cxx:836
 AliAnalysisTaskVnV0.cxx:837
 AliAnalysisTaskVnV0.cxx:838
 AliAnalysisTaskVnV0.cxx:839
 AliAnalysisTaskVnV0.cxx:840
 AliAnalysisTaskVnV0.cxx:841
 AliAnalysisTaskVnV0.cxx:842
 AliAnalysisTaskVnV0.cxx:843
 AliAnalysisTaskVnV0.cxx:844
 AliAnalysisTaskVnV0.cxx:845
 AliAnalysisTaskVnV0.cxx:846
 AliAnalysisTaskVnV0.cxx:847
 AliAnalysisTaskVnV0.cxx:848
 AliAnalysisTaskVnV0.cxx:849
 AliAnalysisTaskVnV0.cxx:850
 AliAnalysisTaskVnV0.cxx:851
 AliAnalysisTaskVnV0.cxx:852
 AliAnalysisTaskVnV0.cxx:853
 AliAnalysisTaskVnV0.cxx:854
 AliAnalysisTaskVnV0.cxx:855
 AliAnalysisTaskVnV0.cxx:856
 AliAnalysisTaskVnV0.cxx:857
 AliAnalysisTaskVnV0.cxx:858
 AliAnalysisTaskVnV0.cxx:859
 AliAnalysisTaskVnV0.cxx:860
 AliAnalysisTaskVnV0.cxx:861
 AliAnalysisTaskVnV0.cxx:862
 AliAnalysisTaskVnV0.cxx:863
 AliAnalysisTaskVnV0.cxx:864
 AliAnalysisTaskVnV0.cxx:865
 AliAnalysisTaskVnV0.cxx:866
 AliAnalysisTaskVnV0.cxx:867
 AliAnalysisTaskVnV0.cxx:868
 AliAnalysisTaskVnV0.cxx:869
 AliAnalysisTaskVnV0.cxx:870
 AliAnalysisTaskVnV0.cxx:871
 AliAnalysisTaskVnV0.cxx:872
 AliAnalysisTaskVnV0.cxx:873
 AliAnalysisTaskVnV0.cxx:874
 AliAnalysisTaskVnV0.cxx:875
 AliAnalysisTaskVnV0.cxx:876
 AliAnalysisTaskVnV0.cxx:877
 AliAnalysisTaskVnV0.cxx:878
 AliAnalysisTaskVnV0.cxx:879
 AliAnalysisTaskVnV0.cxx:880
 AliAnalysisTaskVnV0.cxx:881
 AliAnalysisTaskVnV0.cxx:882
 AliAnalysisTaskVnV0.cxx:883
 AliAnalysisTaskVnV0.cxx:884
 AliAnalysisTaskVnV0.cxx:885
 AliAnalysisTaskVnV0.cxx:886
 AliAnalysisTaskVnV0.cxx:887
 AliAnalysisTaskVnV0.cxx:888
 AliAnalysisTaskVnV0.cxx:889
 AliAnalysisTaskVnV0.cxx:890
 AliAnalysisTaskVnV0.cxx:891
 AliAnalysisTaskVnV0.cxx:892
 AliAnalysisTaskVnV0.cxx:893
 AliAnalysisTaskVnV0.cxx:894
 AliAnalysisTaskVnV0.cxx:895
 AliAnalysisTaskVnV0.cxx:896
 AliAnalysisTaskVnV0.cxx:897
 AliAnalysisTaskVnV0.cxx:898
 AliAnalysisTaskVnV0.cxx:899
 AliAnalysisTaskVnV0.cxx:900
 AliAnalysisTaskVnV0.cxx:901
 AliAnalysisTaskVnV0.cxx:902
 AliAnalysisTaskVnV0.cxx:903
 AliAnalysisTaskVnV0.cxx:904
 AliAnalysisTaskVnV0.cxx:905
 AliAnalysisTaskVnV0.cxx:906
 AliAnalysisTaskVnV0.cxx:907
 AliAnalysisTaskVnV0.cxx:908
 AliAnalysisTaskVnV0.cxx:909
 AliAnalysisTaskVnV0.cxx:910
 AliAnalysisTaskVnV0.cxx:911
 AliAnalysisTaskVnV0.cxx:912
 AliAnalysisTaskVnV0.cxx:913
 AliAnalysisTaskVnV0.cxx:914
 AliAnalysisTaskVnV0.cxx:915
 AliAnalysisTaskVnV0.cxx:916
 AliAnalysisTaskVnV0.cxx:917
 AliAnalysisTaskVnV0.cxx:918
 AliAnalysisTaskVnV0.cxx:919
 AliAnalysisTaskVnV0.cxx:920
 AliAnalysisTaskVnV0.cxx:921
 AliAnalysisTaskVnV0.cxx:922
 AliAnalysisTaskVnV0.cxx:923
 AliAnalysisTaskVnV0.cxx:924
 AliAnalysisTaskVnV0.cxx:925
 AliAnalysisTaskVnV0.cxx:926
 AliAnalysisTaskVnV0.cxx:927
 AliAnalysisTaskVnV0.cxx:928
 AliAnalysisTaskVnV0.cxx:929
 AliAnalysisTaskVnV0.cxx:930
 AliAnalysisTaskVnV0.cxx:931
 AliAnalysisTaskVnV0.cxx:932
 AliAnalysisTaskVnV0.cxx:933
 AliAnalysisTaskVnV0.cxx:934
 AliAnalysisTaskVnV0.cxx:935
 AliAnalysisTaskVnV0.cxx:936
 AliAnalysisTaskVnV0.cxx:937
 AliAnalysisTaskVnV0.cxx:938
 AliAnalysisTaskVnV0.cxx:939
 AliAnalysisTaskVnV0.cxx:940
 AliAnalysisTaskVnV0.cxx:941
 AliAnalysisTaskVnV0.cxx:942
 AliAnalysisTaskVnV0.cxx:943
 AliAnalysisTaskVnV0.cxx:944
 AliAnalysisTaskVnV0.cxx:945
 AliAnalysisTaskVnV0.cxx:946
 AliAnalysisTaskVnV0.cxx:947
 AliAnalysisTaskVnV0.cxx:948
 AliAnalysisTaskVnV0.cxx:949
 AliAnalysisTaskVnV0.cxx:950
 AliAnalysisTaskVnV0.cxx:951
 AliAnalysisTaskVnV0.cxx:952
 AliAnalysisTaskVnV0.cxx:953
 AliAnalysisTaskVnV0.cxx:954
 AliAnalysisTaskVnV0.cxx:955
 AliAnalysisTaskVnV0.cxx:956
 AliAnalysisTaskVnV0.cxx:957
 AliAnalysisTaskVnV0.cxx:958
 AliAnalysisTaskVnV0.cxx:959
 AliAnalysisTaskVnV0.cxx:960
 AliAnalysisTaskVnV0.cxx:961
 AliAnalysisTaskVnV0.cxx:962
 AliAnalysisTaskVnV0.cxx:963
 AliAnalysisTaskVnV0.cxx:964
 AliAnalysisTaskVnV0.cxx:965
 AliAnalysisTaskVnV0.cxx:966
 AliAnalysisTaskVnV0.cxx:967
 AliAnalysisTaskVnV0.cxx:968
 AliAnalysisTaskVnV0.cxx:969
 AliAnalysisTaskVnV0.cxx:970
 AliAnalysisTaskVnV0.cxx:971
 AliAnalysisTaskVnV0.cxx:972
 AliAnalysisTaskVnV0.cxx:973
 AliAnalysisTaskVnV0.cxx:974
 AliAnalysisTaskVnV0.cxx:975
 AliAnalysisTaskVnV0.cxx:976
 AliAnalysisTaskVnV0.cxx:977
 AliAnalysisTaskVnV0.cxx:978
 AliAnalysisTaskVnV0.cxx:979
 AliAnalysisTaskVnV0.cxx:980
 AliAnalysisTaskVnV0.cxx:981
 AliAnalysisTaskVnV0.cxx:982
 AliAnalysisTaskVnV0.cxx:983
 AliAnalysisTaskVnV0.cxx:984
 AliAnalysisTaskVnV0.cxx:985
 AliAnalysisTaskVnV0.cxx:986
 AliAnalysisTaskVnV0.cxx:987
 AliAnalysisTaskVnV0.cxx:988
 AliAnalysisTaskVnV0.cxx:989
 AliAnalysisTaskVnV0.cxx:990
 AliAnalysisTaskVnV0.cxx:991
 AliAnalysisTaskVnV0.cxx:992
 AliAnalysisTaskVnV0.cxx:993
 AliAnalysisTaskVnV0.cxx:994
 AliAnalysisTaskVnV0.cxx:995
 AliAnalysisTaskVnV0.cxx:996
 AliAnalysisTaskVnV0.cxx:997
 AliAnalysisTaskVnV0.cxx:998
 AliAnalysisTaskVnV0.cxx:999
 AliAnalysisTaskVnV0.cxx:1000
 AliAnalysisTaskVnV0.cxx:1001
 AliAnalysisTaskVnV0.cxx:1002
 AliAnalysisTaskVnV0.cxx:1003
 AliAnalysisTaskVnV0.cxx:1004
 AliAnalysisTaskVnV0.cxx:1005
 AliAnalysisTaskVnV0.cxx:1006
 AliAnalysisTaskVnV0.cxx:1007
 AliAnalysisTaskVnV0.cxx:1008
 AliAnalysisTaskVnV0.cxx:1009
 AliAnalysisTaskVnV0.cxx:1010
 AliAnalysisTaskVnV0.cxx:1011
 AliAnalysisTaskVnV0.cxx:1012
 AliAnalysisTaskVnV0.cxx:1013
 AliAnalysisTaskVnV0.cxx:1014
 AliAnalysisTaskVnV0.cxx:1015
 AliAnalysisTaskVnV0.cxx:1016
 AliAnalysisTaskVnV0.cxx:1017
 AliAnalysisTaskVnV0.cxx:1018
 AliAnalysisTaskVnV0.cxx:1019
 AliAnalysisTaskVnV0.cxx:1020
 AliAnalysisTaskVnV0.cxx:1021
 AliAnalysisTaskVnV0.cxx:1022
 AliAnalysisTaskVnV0.cxx:1023
 AliAnalysisTaskVnV0.cxx:1024
 AliAnalysisTaskVnV0.cxx:1025
 AliAnalysisTaskVnV0.cxx:1026
 AliAnalysisTaskVnV0.cxx:1027
 AliAnalysisTaskVnV0.cxx:1028
 AliAnalysisTaskVnV0.cxx:1029
 AliAnalysisTaskVnV0.cxx:1030
 AliAnalysisTaskVnV0.cxx:1031
 AliAnalysisTaskVnV0.cxx:1032
 AliAnalysisTaskVnV0.cxx:1033
 AliAnalysisTaskVnV0.cxx:1034
 AliAnalysisTaskVnV0.cxx:1035
 AliAnalysisTaskVnV0.cxx:1036
 AliAnalysisTaskVnV0.cxx:1037
 AliAnalysisTaskVnV0.cxx:1038
 AliAnalysisTaskVnV0.cxx:1039
 AliAnalysisTaskVnV0.cxx:1040
 AliAnalysisTaskVnV0.cxx:1041
 AliAnalysisTaskVnV0.cxx:1042
 AliAnalysisTaskVnV0.cxx:1043
 AliAnalysisTaskVnV0.cxx:1044
 AliAnalysisTaskVnV0.cxx:1045
 AliAnalysisTaskVnV0.cxx:1046
 AliAnalysisTaskVnV0.cxx:1047
 AliAnalysisTaskVnV0.cxx:1048
 AliAnalysisTaskVnV0.cxx:1049
 AliAnalysisTaskVnV0.cxx:1050
 AliAnalysisTaskVnV0.cxx:1051
 AliAnalysisTaskVnV0.cxx:1052
 AliAnalysisTaskVnV0.cxx:1053
 AliAnalysisTaskVnV0.cxx:1054
 AliAnalysisTaskVnV0.cxx:1055
 AliAnalysisTaskVnV0.cxx:1056
 AliAnalysisTaskVnV0.cxx:1057
 AliAnalysisTaskVnV0.cxx:1058
 AliAnalysisTaskVnV0.cxx:1059
 AliAnalysisTaskVnV0.cxx:1060
 AliAnalysisTaskVnV0.cxx:1061
 AliAnalysisTaskVnV0.cxx:1062
 AliAnalysisTaskVnV0.cxx:1063
 AliAnalysisTaskVnV0.cxx:1064
 AliAnalysisTaskVnV0.cxx:1065
 AliAnalysisTaskVnV0.cxx:1066
 AliAnalysisTaskVnV0.cxx:1067
 AliAnalysisTaskVnV0.cxx:1068
 AliAnalysisTaskVnV0.cxx:1069
 AliAnalysisTaskVnV0.cxx:1070
 AliAnalysisTaskVnV0.cxx:1071
 AliAnalysisTaskVnV0.cxx:1072
 AliAnalysisTaskVnV0.cxx:1073
 AliAnalysisTaskVnV0.cxx:1074
 AliAnalysisTaskVnV0.cxx:1075
 AliAnalysisTaskVnV0.cxx:1076
 AliAnalysisTaskVnV0.cxx:1077
 AliAnalysisTaskVnV0.cxx:1078
 AliAnalysisTaskVnV0.cxx:1079
 AliAnalysisTaskVnV0.cxx:1080
 AliAnalysisTaskVnV0.cxx:1081
 AliAnalysisTaskVnV0.cxx:1082
 AliAnalysisTaskVnV0.cxx:1083
 AliAnalysisTaskVnV0.cxx:1084
 AliAnalysisTaskVnV0.cxx:1085
 AliAnalysisTaskVnV0.cxx:1086
 AliAnalysisTaskVnV0.cxx:1087
 AliAnalysisTaskVnV0.cxx:1088
 AliAnalysisTaskVnV0.cxx:1089
 AliAnalysisTaskVnV0.cxx:1090
 AliAnalysisTaskVnV0.cxx:1091
 AliAnalysisTaskVnV0.cxx:1092
 AliAnalysisTaskVnV0.cxx:1093
 AliAnalysisTaskVnV0.cxx:1094
 AliAnalysisTaskVnV0.cxx:1095
 AliAnalysisTaskVnV0.cxx:1096
 AliAnalysisTaskVnV0.cxx:1097
 AliAnalysisTaskVnV0.cxx:1098
 AliAnalysisTaskVnV0.cxx:1099
 AliAnalysisTaskVnV0.cxx:1100
 AliAnalysisTaskVnV0.cxx:1101
 AliAnalysisTaskVnV0.cxx:1102
 AliAnalysisTaskVnV0.cxx:1103
 AliAnalysisTaskVnV0.cxx:1104
 AliAnalysisTaskVnV0.cxx:1105
 AliAnalysisTaskVnV0.cxx:1106
 AliAnalysisTaskVnV0.cxx:1107
 AliAnalysisTaskVnV0.cxx:1108
 AliAnalysisTaskVnV0.cxx:1109
 AliAnalysisTaskVnV0.cxx:1110
 AliAnalysisTaskVnV0.cxx:1111
 AliAnalysisTaskVnV0.cxx:1112
 AliAnalysisTaskVnV0.cxx:1113
 AliAnalysisTaskVnV0.cxx:1114
 AliAnalysisTaskVnV0.cxx:1115
 AliAnalysisTaskVnV0.cxx:1116
 AliAnalysisTaskVnV0.cxx:1117
 AliAnalysisTaskVnV0.cxx:1118
 AliAnalysisTaskVnV0.cxx:1119
 AliAnalysisTaskVnV0.cxx:1120
 AliAnalysisTaskVnV0.cxx:1121
 AliAnalysisTaskVnV0.cxx:1122
 AliAnalysisTaskVnV0.cxx:1123
 AliAnalysisTaskVnV0.cxx:1124
 AliAnalysisTaskVnV0.cxx:1125
 AliAnalysisTaskVnV0.cxx:1126
 AliAnalysisTaskVnV0.cxx:1127
 AliAnalysisTaskVnV0.cxx:1128
 AliAnalysisTaskVnV0.cxx:1129
 AliAnalysisTaskVnV0.cxx:1130
 AliAnalysisTaskVnV0.cxx:1131
 AliAnalysisTaskVnV0.cxx:1132
 AliAnalysisTaskVnV0.cxx:1133
 AliAnalysisTaskVnV0.cxx:1134
 AliAnalysisTaskVnV0.cxx:1135
 AliAnalysisTaskVnV0.cxx:1136
 AliAnalysisTaskVnV0.cxx:1137
 AliAnalysisTaskVnV0.cxx:1138
 AliAnalysisTaskVnV0.cxx:1139
 AliAnalysisTaskVnV0.cxx:1140
 AliAnalysisTaskVnV0.cxx:1141
 AliAnalysisTaskVnV0.cxx:1142
 AliAnalysisTaskVnV0.cxx:1143
 AliAnalysisTaskVnV0.cxx:1144
 AliAnalysisTaskVnV0.cxx:1145
 AliAnalysisTaskVnV0.cxx:1146
 AliAnalysisTaskVnV0.cxx:1147
 AliAnalysisTaskVnV0.cxx:1148
 AliAnalysisTaskVnV0.cxx:1149
 AliAnalysisTaskVnV0.cxx:1150
 AliAnalysisTaskVnV0.cxx:1151
 AliAnalysisTaskVnV0.cxx:1152
 AliAnalysisTaskVnV0.cxx:1153
 AliAnalysisTaskVnV0.cxx:1154
 AliAnalysisTaskVnV0.cxx:1155
 AliAnalysisTaskVnV0.cxx:1156
 AliAnalysisTaskVnV0.cxx:1157
 AliAnalysisTaskVnV0.cxx:1158
 AliAnalysisTaskVnV0.cxx:1159
 AliAnalysisTaskVnV0.cxx:1160
 AliAnalysisTaskVnV0.cxx:1161
 AliAnalysisTaskVnV0.cxx:1162
 AliAnalysisTaskVnV0.cxx:1163
 AliAnalysisTaskVnV0.cxx:1164
 AliAnalysisTaskVnV0.cxx:1165
 AliAnalysisTaskVnV0.cxx:1166
 AliAnalysisTaskVnV0.cxx:1167
 AliAnalysisTaskVnV0.cxx:1168
 AliAnalysisTaskVnV0.cxx:1169
 AliAnalysisTaskVnV0.cxx:1170
 AliAnalysisTaskVnV0.cxx:1171
 AliAnalysisTaskVnV0.cxx:1172
 AliAnalysisTaskVnV0.cxx:1173
 AliAnalysisTaskVnV0.cxx:1174
 AliAnalysisTaskVnV0.cxx:1175
 AliAnalysisTaskVnV0.cxx:1176
 AliAnalysisTaskVnV0.cxx:1177
 AliAnalysisTaskVnV0.cxx:1178
 AliAnalysisTaskVnV0.cxx:1179
 AliAnalysisTaskVnV0.cxx:1180
 AliAnalysisTaskVnV0.cxx:1181
 AliAnalysisTaskVnV0.cxx:1182
 AliAnalysisTaskVnV0.cxx:1183
 AliAnalysisTaskVnV0.cxx:1184
 AliAnalysisTaskVnV0.cxx:1185
 AliAnalysisTaskVnV0.cxx:1186
 AliAnalysisTaskVnV0.cxx:1187
 AliAnalysisTaskVnV0.cxx:1188
 AliAnalysisTaskVnV0.cxx:1189
 AliAnalysisTaskVnV0.cxx:1190
 AliAnalysisTaskVnV0.cxx:1191
 AliAnalysisTaskVnV0.cxx:1192
 AliAnalysisTaskVnV0.cxx:1193
 AliAnalysisTaskVnV0.cxx:1194
 AliAnalysisTaskVnV0.cxx:1195
 AliAnalysisTaskVnV0.cxx:1196
 AliAnalysisTaskVnV0.cxx:1197
 AliAnalysisTaskVnV0.cxx:1198
 AliAnalysisTaskVnV0.cxx:1199
 AliAnalysisTaskVnV0.cxx:1200
 AliAnalysisTaskVnV0.cxx:1201
 AliAnalysisTaskVnV0.cxx:1202
 AliAnalysisTaskVnV0.cxx:1203
 AliAnalysisTaskVnV0.cxx:1204
 AliAnalysisTaskVnV0.cxx:1205
 AliAnalysisTaskVnV0.cxx:1206
 AliAnalysisTaskVnV0.cxx:1207
 AliAnalysisTaskVnV0.cxx:1208
 AliAnalysisTaskVnV0.cxx:1209
 AliAnalysisTaskVnV0.cxx:1210
 AliAnalysisTaskVnV0.cxx:1211
 AliAnalysisTaskVnV0.cxx:1212
 AliAnalysisTaskVnV0.cxx:1213
 AliAnalysisTaskVnV0.cxx:1214
 AliAnalysisTaskVnV0.cxx:1215
 AliAnalysisTaskVnV0.cxx:1216
 AliAnalysisTaskVnV0.cxx:1217
 AliAnalysisTaskVnV0.cxx:1218
 AliAnalysisTaskVnV0.cxx:1219
 AliAnalysisTaskVnV0.cxx:1220
 AliAnalysisTaskVnV0.cxx:1221
 AliAnalysisTaskVnV0.cxx:1222
 AliAnalysisTaskVnV0.cxx:1223
 AliAnalysisTaskVnV0.cxx:1224
 AliAnalysisTaskVnV0.cxx:1225
 AliAnalysisTaskVnV0.cxx:1226
 AliAnalysisTaskVnV0.cxx:1227
 AliAnalysisTaskVnV0.cxx:1228
 AliAnalysisTaskVnV0.cxx:1229
 AliAnalysisTaskVnV0.cxx:1230
 AliAnalysisTaskVnV0.cxx:1231
 AliAnalysisTaskVnV0.cxx:1232
 AliAnalysisTaskVnV0.cxx:1233
 AliAnalysisTaskVnV0.cxx:1234
 AliAnalysisTaskVnV0.cxx:1235
 AliAnalysisTaskVnV0.cxx:1236
 AliAnalysisTaskVnV0.cxx:1237
 AliAnalysisTaskVnV0.cxx:1238
 AliAnalysisTaskVnV0.cxx:1239
 AliAnalysisTaskVnV0.cxx:1240
 AliAnalysisTaskVnV0.cxx:1241
 AliAnalysisTaskVnV0.cxx:1242
 AliAnalysisTaskVnV0.cxx:1243
 AliAnalysisTaskVnV0.cxx:1244
 AliAnalysisTaskVnV0.cxx:1245
 AliAnalysisTaskVnV0.cxx:1246
 AliAnalysisTaskVnV0.cxx:1247
 AliAnalysisTaskVnV0.cxx:1248
 AliAnalysisTaskVnV0.cxx:1249
 AliAnalysisTaskVnV0.cxx:1250
 AliAnalysisTaskVnV0.cxx:1251
 AliAnalysisTaskVnV0.cxx:1252
 AliAnalysisTaskVnV0.cxx:1253
 AliAnalysisTaskVnV0.cxx:1254
 AliAnalysisTaskVnV0.cxx:1255
 AliAnalysisTaskVnV0.cxx:1256
 AliAnalysisTaskVnV0.cxx:1257
 AliAnalysisTaskVnV0.cxx:1258
 AliAnalysisTaskVnV0.cxx:1259
 AliAnalysisTaskVnV0.cxx:1260
 AliAnalysisTaskVnV0.cxx:1261
 AliAnalysisTaskVnV0.cxx:1262
 AliAnalysisTaskVnV0.cxx:1263
 AliAnalysisTaskVnV0.cxx:1264
 AliAnalysisTaskVnV0.cxx:1265
 AliAnalysisTaskVnV0.cxx:1266
 AliAnalysisTaskVnV0.cxx:1267
 AliAnalysisTaskVnV0.cxx:1268
 AliAnalysisTaskVnV0.cxx:1269
 AliAnalysisTaskVnV0.cxx:1270
 AliAnalysisTaskVnV0.cxx:1271
 AliAnalysisTaskVnV0.cxx:1272
 AliAnalysisTaskVnV0.cxx:1273
 AliAnalysisTaskVnV0.cxx:1274
 AliAnalysisTaskVnV0.cxx:1275
 AliAnalysisTaskVnV0.cxx:1276
 AliAnalysisTaskVnV0.cxx:1277
 AliAnalysisTaskVnV0.cxx:1278
 AliAnalysisTaskVnV0.cxx:1279
 AliAnalysisTaskVnV0.cxx:1280
 AliAnalysisTaskVnV0.cxx:1281
 AliAnalysisTaskVnV0.cxx:1282
 AliAnalysisTaskVnV0.cxx:1283
 AliAnalysisTaskVnV0.cxx:1284
 AliAnalysisTaskVnV0.cxx:1285
 AliAnalysisTaskVnV0.cxx:1286
 AliAnalysisTaskVnV0.cxx:1287
 AliAnalysisTaskVnV0.cxx:1288
 AliAnalysisTaskVnV0.cxx:1289
 AliAnalysisTaskVnV0.cxx:1290
 AliAnalysisTaskVnV0.cxx:1291
 AliAnalysisTaskVnV0.cxx:1292
 AliAnalysisTaskVnV0.cxx:1293
 AliAnalysisTaskVnV0.cxx:1294
 AliAnalysisTaskVnV0.cxx:1295
 AliAnalysisTaskVnV0.cxx:1296
 AliAnalysisTaskVnV0.cxx:1297
 AliAnalysisTaskVnV0.cxx:1298
 AliAnalysisTaskVnV0.cxx:1299
 AliAnalysisTaskVnV0.cxx:1300
 AliAnalysisTaskVnV0.cxx:1301
 AliAnalysisTaskVnV0.cxx:1302
 AliAnalysisTaskVnV0.cxx:1303
 AliAnalysisTaskVnV0.cxx:1304
 AliAnalysisTaskVnV0.cxx:1305
 AliAnalysisTaskVnV0.cxx:1306
 AliAnalysisTaskVnV0.cxx:1307
 AliAnalysisTaskVnV0.cxx:1308
 AliAnalysisTaskVnV0.cxx:1309
 AliAnalysisTaskVnV0.cxx:1310
 AliAnalysisTaskVnV0.cxx:1311
 AliAnalysisTaskVnV0.cxx:1312
 AliAnalysisTaskVnV0.cxx:1313
 AliAnalysisTaskVnV0.cxx:1314
 AliAnalysisTaskVnV0.cxx:1315
 AliAnalysisTaskVnV0.cxx:1316
 AliAnalysisTaskVnV0.cxx:1317
 AliAnalysisTaskVnV0.cxx:1318
 AliAnalysisTaskVnV0.cxx:1319
 AliAnalysisTaskVnV0.cxx:1320
 AliAnalysisTaskVnV0.cxx:1321
 AliAnalysisTaskVnV0.cxx:1322
 AliAnalysisTaskVnV0.cxx:1323
 AliAnalysisTaskVnV0.cxx:1324
 AliAnalysisTaskVnV0.cxx:1325
 AliAnalysisTaskVnV0.cxx:1326
 AliAnalysisTaskVnV0.cxx:1327
 AliAnalysisTaskVnV0.cxx:1328
 AliAnalysisTaskVnV0.cxx:1329
 AliAnalysisTaskVnV0.cxx:1330
 AliAnalysisTaskVnV0.cxx:1331
 AliAnalysisTaskVnV0.cxx:1332
 AliAnalysisTaskVnV0.cxx:1333
 AliAnalysisTaskVnV0.cxx:1334
 AliAnalysisTaskVnV0.cxx:1335
 AliAnalysisTaskVnV0.cxx:1336
 AliAnalysisTaskVnV0.cxx:1337
 AliAnalysisTaskVnV0.cxx:1338
 AliAnalysisTaskVnV0.cxx:1339
 AliAnalysisTaskVnV0.cxx:1340
 AliAnalysisTaskVnV0.cxx:1341
 AliAnalysisTaskVnV0.cxx:1342
 AliAnalysisTaskVnV0.cxx:1343
 AliAnalysisTaskVnV0.cxx:1344
 AliAnalysisTaskVnV0.cxx:1345
 AliAnalysisTaskVnV0.cxx:1346
 AliAnalysisTaskVnV0.cxx:1347
 AliAnalysisTaskVnV0.cxx:1348
 AliAnalysisTaskVnV0.cxx:1349
 AliAnalysisTaskVnV0.cxx:1350
 AliAnalysisTaskVnV0.cxx:1351
 AliAnalysisTaskVnV0.cxx:1352
 AliAnalysisTaskVnV0.cxx:1353
 AliAnalysisTaskVnV0.cxx:1354
 AliAnalysisTaskVnV0.cxx:1355
 AliAnalysisTaskVnV0.cxx:1356
 AliAnalysisTaskVnV0.cxx:1357
 AliAnalysisTaskVnV0.cxx:1358
 AliAnalysisTaskVnV0.cxx:1359
 AliAnalysisTaskVnV0.cxx:1360
 AliAnalysisTaskVnV0.cxx:1361
 AliAnalysisTaskVnV0.cxx:1362
 AliAnalysisTaskVnV0.cxx:1363
 AliAnalysisTaskVnV0.cxx:1364
 AliAnalysisTaskVnV0.cxx:1365
 AliAnalysisTaskVnV0.cxx:1366
 AliAnalysisTaskVnV0.cxx:1367
 AliAnalysisTaskVnV0.cxx:1368
 AliAnalysisTaskVnV0.cxx:1369
 AliAnalysisTaskVnV0.cxx:1370
 AliAnalysisTaskVnV0.cxx:1371
 AliAnalysisTaskVnV0.cxx:1372
 AliAnalysisTaskVnV0.cxx:1373
 AliAnalysisTaskVnV0.cxx:1374
 AliAnalysisTaskVnV0.cxx:1375
 AliAnalysisTaskVnV0.cxx:1376
 AliAnalysisTaskVnV0.cxx:1377
 AliAnalysisTaskVnV0.cxx:1378
 AliAnalysisTaskVnV0.cxx:1379
 AliAnalysisTaskVnV0.cxx:1380
 AliAnalysisTaskVnV0.cxx:1381
 AliAnalysisTaskVnV0.cxx:1382
 AliAnalysisTaskVnV0.cxx:1383
 AliAnalysisTaskVnV0.cxx:1384
 AliAnalysisTaskVnV0.cxx:1385
 AliAnalysisTaskVnV0.cxx:1386
 AliAnalysisTaskVnV0.cxx:1387
 AliAnalysisTaskVnV0.cxx:1388
 AliAnalysisTaskVnV0.cxx:1389
 AliAnalysisTaskVnV0.cxx:1390
 AliAnalysisTaskVnV0.cxx:1391
 AliAnalysisTaskVnV0.cxx:1392
 AliAnalysisTaskVnV0.cxx:1393
 AliAnalysisTaskVnV0.cxx:1394
 AliAnalysisTaskVnV0.cxx:1395
 AliAnalysisTaskVnV0.cxx:1396
 AliAnalysisTaskVnV0.cxx:1397
 AliAnalysisTaskVnV0.cxx:1398
 AliAnalysisTaskVnV0.cxx:1399
 AliAnalysisTaskVnV0.cxx:1400
 AliAnalysisTaskVnV0.cxx:1401
 AliAnalysisTaskVnV0.cxx:1402
 AliAnalysisTaskVnV0.cxx:1403
 AliAnalysisTaskVnV0.cxx:1404
 AliAnalysisTaskVnV0.cxx:1405
 AliAnalysisTaskVnV0.cxx:1406
 AliAnalysisTaskVnV0.cxx:1407
 AliAnalysisTaskVnV0.cxx:1408
 AliAnalysisTaskVnV0.cxx:1409
 AliAnalysisTaskVnV0.cxx:1410
 AliAnalysisTaskVnV0.cxx:1411
 AliAnalysisTaskVnV0.cxx:1412
 AliAnalysisTaskVnV0.cxx:1413
 AliAnalysisTaskVnV0.cxx:1414
 AliAnalysisTaskVnV0.cxx:1415
 AliAnalysisTaskVnV0.cxx:1416
 AliAnalysisTaskVnV0.cxx:1417
 AliAnalysisTaskVnV0.cxx:1418
 AliAnalysisTaskVnV0.cxx:1419
 AliAnalysisTaskVnV0.cxx:1420
 AliAnalysisTaskVnV0.cxx:1421
 AliAnalysisTaskVnV0.cxx:1422
 AliAnalysisTaskVnV0.cxx:1423
 AliAnalysisTaskVnV0.cxx:1424
 AliAnalysisTaskVnV0.cxx:1425
 AliAnalysisTaskVnV0.cxx:1426
 AliAnalysisTaskVnV0.cxx:1427
 AliAnalysisTaskVnV0.cxx:1428
 AliAnalysisTaskVnV0.cxx:1429
 AliAnalysisTaskVnV0.cxx:1430
 AliAnalysisTaskVnV0.cxx:1431
 AliAnalysisTaskVnV0.cxx:1432
 AliAnalysisTaskVnV0.cxx:1433
 AliAnalysisTaskVnV0.cxx:1434
 AliAnalysisTaskVnV0.cxx:1435
 AliAnalysisTaskVnV0.cxx:1436
 AliAnalysisTaskVnV0.cxx:1437
 AliAnalysisTaskVnV0.cxx:1438
 AliAnalysisTaskVnV0.cxx:1439
 AliAnalysisTaskVnV0.cxx:1440
 AliAnalysisTaskVnV0.cxx:1441
 AliAnalysisTaskVnV0.cxx:1442
 AliAnalysisTaskVnV0.cxx:1443
 AliAnalysisTaskVnV0.cxx:1444
 AliAnalysisTaskVnV0.cxx:1445
 AliAnalysisTaskVnV0.cxx:1446
 AliAnalysisTaskVnV0.cxx:1447
 AliAnalysisTaskVnV0.cxx:1448
 AliAnalysisTaskVnV0.cxx:1449
 AliAnalysisTaskVnV0.cxx:1450
 AliAnalysisTaskVnV0.cxx:1451
 AliAnalysisTaskVnV0.cxx:1452
 AliAnalysisTaskVnV0.cxx:1453
 AliAnalysisTaskVnV0.cxx:1454
 AliAnalysisTaskVnV0.cxx:1455
 AliAnalysisTaskVnV0.cxx:1456
 AliAnalysisTaskVnV0.cxx:1457
 AliAnalysisTaskVnV0.cxx:1458
 AliAnalysisTaskVnV0.cxx:1459
 AliAnalysisTaskVnV0.cxx:1460
 AliAnalysisTaskVnV0.cxx:1461
 AliAnalysisTaskVnV0.cxx:1462
 AliAnalysisTaskVnV0.cxx:1463
 AliAnalysisTaskVnV0.cxx:1464
 AliAnalysisTaskVnV0.cxx:1465
 AliAnalysisTaskVnV0.cxx:1466
 AliAnalysisTaskVnV0.cxx:1467
 AliAnalysisTaskVnV0.cxx:1468
 AliAnalysisTaskVnV0.cxx:1469
 AliAnalysisTaskVnV0.cxx:1470
 AliAnalysisTaskVnV0.cxx:1471
 AliAnalysisTaskVnV0.cxx:1472
 AliAnalysisTaskVnV0.cxx:1473
 AliAnalysisTaskVnV0.cxx:1474
 AliAnalysisTaskVnV0.cxx:1475
 AliAnalysisTaskVnV0.cxx:1476
 AliAnalysisTaskVnV0.cxx:1477
 AliAnalysisTaskVnV0.cxx:1478
 AliAnalysisTaskVnV0.cxx:1479
 AliAnalysisTaskVnV0.cxx:1480
 AliAnalysisTaskVnV0.cxx:1481
 AliAnalysisTaskVnV0.cxx:1482
 AliAnalysisTaskVnV0.cxx:1483
 AliAnalysisTaskVnV0.cxx:1484
 AliAnalysisTaskVnV0.cxx:1485
 AliAnalysisTaskVnV0.cxx:1486
 AliAnalysisTaskVnV0.cxx:1487
 AliAnalysisTaskVnV0.cxx:1488
 AliAnalysisTaskVnV0.cxx:1489
 AliAnalysisTaskVnV0.cxx:1490
 AliAnalysisTaskVnV0.cxx:1491
 AliAnalysisTaskVnV0.cxx:1492
 AliAnalysisTaskVnV0.cxx:1493
 AliAnalysisTaskVnV0.cxx:1494
 AliAnalysisTaskVnV0.cxx:1495
 AliAnalysisTaskVnV0.cxx:1496
 AliAnalysisTaskVnV0.cxx:1497
 AliAnalysisTaskVnV0.cxx:1498
 AliAnalysisTaskVnV0.cxx:1499
 AliAnalysisTaskVnV0.cxx:1500
 AliAnalysisTaskVnV0.cxx:1501
 AliAnalysisTaskVnV0.cxx:1502
 AliAnalysisTaskVnV0.cxx:1503
 AliAnalysisTaskVnV0.cxx:1504
 AliAnalysisTaskVnV0.cxx:1505
 AliAnalysisTaskVnV0.cxx:1506
 AliAnalysisTaskVnV0.cxx:1507
 AliAnalysisTaskVnV0.cxx:1508
 AliAnalysisTaskVnV0.cxx:1509
 AliAnalysisTaskVnV0.cxx:1510
 AliAnalysisTaskVnV0.cxx:1511
 AliAnalysisTaskVnV0.cxx:1512
 AliAnalysisTaskVnV0.cxx:1513
 AliAnalysisTaskVnV0.cxx:1514
 AliAnalysisTaskVnV0.cxx:1515
 AliAnalysisTaskVnV0.cxx:1516
 AliAnalysisTaskVnV0.cxx:1517
 AliAnalysisTaskVnV0.cxx:1518
 AliAnalysisTaskVnV0.cxx:1519
 AliAnalysisTaskVnV0.cxx:1520
 AliAnalysisTaskVnV0.cxx:1521
 AliAnalysisTaskVnV0.cxx:1522
 AliAnalysisTaskVnV0.cxx:1523
 AliAnalysisTaskVnV0.cxx:1524
 AliAnalysisTaskVnV0.cxx:1525
 AliAnalysisTaskVnV0.cxx:1526
 AliAnalysisTaskVnV0.cxx:1527
 AliAnalysisTaskVnV0.cxx:1528
 AliAnalysisTaskVnV0.cxx:1529
 AliAnalysisTaskVnV0.cxx:1530
 AliAnalysisTaskVnV0.cxx:1531
 AliAnalysisTaskVnV0.cxx:1532
 AliAnalysisTaskVnV0.cxx:1533
 AliAnalysisTaskVnV0.cxx:1534
 AliAnalysisTaskVnV0.cxx:1535
 AliAnalysisTaskVnV0.cxx:1536
 AliAnalysisTaskVnV0.cxx:1537
 AliAnalysisTaskVnV0.cxx:1538
 AliAnalysisTaskVnV0.cxx:1539
 AliAnalysisTaskVnV0.cxx:1540
 AliAnalysisTaskVnV0.cxx:1541
 AliAnalysisTaskVnV0.cxx:1542
 AliAnalysisTaskVnV0.cxx:1543
 AliAnalysisTaskVnV0.cxx:1544
 AliAnalysisTaskVnV0.cxx:1545
 AliAnalysisTaskVnV0.cxx:1546
 AliAnalysisTaskVnV0.cxx:1547
 AliAnalysisTaskVnV0.cxx:1548
 AliAnalysisTaskVnV0.cxx:1549
 AliAnalysisTaskVnV0.cxx:1550
 AliAnalysisTaskVnV0.cxx:1551
 AliAnalysisTaskVnV0.cxx:1552
 AliAnalysisTaskVnV0.cxx:1553
 AliAnalysisTaskVnV0.cxx:1554
 AliAnalysisTaskVnV0.cxx:1555
 AliAnalysisTaskVnV0.cxx:1556
 AliAnalysisTaskVnV0.cxx:1557
 AliAnalysisTaskVnV0.cxx:1558
 AliAnalysisTaskVnV0.cxx:1559
 AliAnalysisTaskVnV0.cxx:1560
 AliAnalysisTaskVnV0.cxx:1561
 AliAnalysisTaskVnV0.cxx:1562
 AliAnalysisTaskVnV0.cxx:1563
 AliAnalysisTaskVnV0.cxx:1564
 AliAnalysisTaskVnV0.cxx:1565
 AliAnalysisTaskVnV0.cxx:1566
 AliAnalysisTaskVnV0.cxx:1567
 AliAnalysisTaskVnV0.cxx:1568
 AliAnalysisTaskVnV0.cxx:1569
 AliAnalysisTaskVnV0.cxx:1570
 AliAnalysisTaskVnV0.cxx:1571
 AliAnalysisTaskVnV0.cxx:1572
 AliAnalysisTaskVnV0.cxx:1573
 AliAnalysisTaskVnV0.cxx:1574
 AliAnalysisTaskVnV0.cxx:1575
 AliAnalysisTaskVnV0.cxx:1576
 AliAnalysisTaskVnV0.cxx:1577
 AliAnalysisTaskVnV0.cxx:1578
 AliAnalysisTaskVnV0.cxx:1579
 AliAnalysisTaskVnV0.cxx:1580
 AliAnalysisTaskVnV0.cxx:1581
 AliAnalysisTaskVnV0.cxx:1582
 AliAnalysisTaskVnV0.cxx:1583
 AliAnalysisTaskVnV0.cxx:1584
 AliAnalysisTaskVnV0.cxx:1585
 AliAnalysisTaskVnV0.cxx:1586
 AliAnalysisTaskVnV0.cxx:1587
 AliAnalysisTaskVnV0.cxx:1588
 AliAnalysisTaskVnV0.cxx:1589
 AliAnalysisTaskVnV0.cxx:1590
 AliAnalysisTaskVnV0.cxx:1591
 AliAnalysisTaskVnV0.cxx:1592
 AliAnalysisTaskVnV0.cxx:1593
 AliAnalysisTaskVnV0.cxx:1594
 AliAnalysisTaskVnV0.cxx:1595
 AliAnalysisTaskVnV0.cxx:1596
 AliAnalysisTaskVnV0.cxx:1597
 AliAnalysisTaskVnV0.cxx:1598
 AliAnalysisTaskVnV0.cxx:1599
 AliAnalysisTaskVnV0.cxx:1600
 AliAnalysisTaskVnV0.cxx:1601
 AliAnalysisTaskVnV0.cxx:1602
 AliAnalysisTaskVnV0.cxx:1603
 AliAnalysisTaskVnV0.cxx:1604
 AliAnalysisTaskVnV0.cxx:1605
 AliAnalysisTaskVnV0.cxx:1606
 AliAnalysisTaskVnV0.cxx:1607
 AliAnalysisTaskVnV0.cxx:1608
 AliAnalysisTaskVnV0.cxx:1609
 AliAnalysisTaskVnV0.cxx:1610
 AliAnalysisTaskVnV0.cxx:1611
 AliAnalysisTaskVnV0.cxx:1612
 AliAnalysisTaskVnV0.cxx:1613
 AliAnalysisTaskVnV0.cxx:1614
 AliAnalysisTaskVnV0.cxx:1615
 AliAnalysisTaskVnV0.cxx:1616
 AliAnalysisTaskVnV0.cxx:1617
 AliAnalysisTaskVnV0.cxx:1618
 AliAnalysisTaskVnV0.cxx:1619
 AliAnalysisTaskVnV0.cxx:1620
 AliAnalysisTaskVnV0.cxx:1621
 AliAnalysisTaskVnV0.cxx:1622
 AliAnalysisTaskVnV0.cxx:1623
 AliAnalysisTaskVnV0.cxx:1624
 AliAnalysisTaskVnV0.cxx:1625
 AliAnalysisTaskVnV0.cxx:1626
 AliAnalysisTaskVnV0.cxx:1627
 AliAnalysisTaskVnV0.cxx:1628
 AliAnalysisTaskVnV0.cxx:1629
 AliAnalysisTaskVnV0.cxx:1630
 AliAnalysisTaskVnV0.cxx:1631
 AliAnalysisTaskVnV0.cxx:1632
 AliAnalysisTaskVnV0.cxx:1633
 AliAnalysisTaskVnV0.cxx:1634
 AliAnalysisTaskVnV0.cxx:1635
 AliAnalysisTaskVnV0.cxx:1636
 AliAnalysisTaskVnV0.cxx:1637
 AliAnalysisTaskVnV0.cxx:1638
 AliAnalysisTaskVnV0.cxx:1639
 AliAnalysisTaskVnV0.cxx:1640
 AliAnalysisTaskVnV0.cxx:1641
 AliAnalysisTaskVnV0.cxx:1642
 AliAnalysisTaskVnV0.cxx:1643
 AliAnalysisTaskVnV0.cxx:1644
 AliAnalysisTaskVnV0.cxx:1645
 AliAnalysisTaskVnV0.cxx:1646
 AliAnalysisTaskVnV0.cxx:1647
 AliAnalysisTaskVnV0.cxx:1648
 AliAnalysisTaskVnV0.cxx:1649
 AliAnalysisTaskVnV0.cxx:1650
 AliAnalysisTaskVnV0.cxx:1651
 AliAnalysisTaskVnV0.cxx:1652
 AliAnalysisTaskVnV0.cxx:1653
 AliAnalysisTaskVnV0.cxx:1654
 AliAnalysisTaskVnV0.cxx:1655
 AliAnalysisTaskVnV0.cxx:1656
 AliAnalysisTaskVnV0.cxx:1657
 AliAnalysisTaskVnV0.cxx:1658
 AliAnalysisTaskVnV0.cxx:1659
 AliAnalysisTaskVnV0.cxx:1660
 AliAnalysisTaskVnV0.cxx:1661
 AliAnalysisTaskVnV0.cxx:1662
 AliAnalysisTaskVnV0.cxx:1663
 AliAnalysisTaskVnV0.cxx:1664
 AliAnalysisTaskVnV0.cxx:1665
 AliAnalysisTaskVnV0.cxx:1666
 AliAnalysisTaskVnV0.cxx:1667
 AliAnalysisTaskVnV0.cxx:1668
 AliAnalysisTaskVnV0.cxx:1669
 AliAnalysisTaskVnV0.cxx:1670
 AliAnalysisTaskVnV0.cxx:1671
 AliAnalysisTaskVnV0.cxx:1672
 AliAnalysisTaskVnV0.cxx:1673
 AliAnalysisTaskVnV0.cxx:1674
 AliAnalysisTaskVnV0.cxx:1675
 AliAnalysisTaskVnV0.cxx:1676
 AliAnalysisTaskVnV0.cxx:1677
 AliAnalysisTaskVnV0.cxx:1678
 AliAnalysisTaskVnV0.cxx:1679
 AliAnalysisTaskVnV0.cxx:1680
 AliAnalysisTaskVnV0.cxx:1681
 AliAnalysisTaskVnV0.cxx:1682
 AliAnalysisTaskVnV0.cxx:1683
 AliAnalysisTaskVnV0.cxx:1684
 AliAnalysisTaskVnV0.cxx:1685
 AliAnalysisTaskVnV0.cxx:1686
 AliAnalysisTaskVnV0.cxx:1687
 AliAnalysisTaskVnV0.cxx:1688
 AliAnalysisTaskVnV0.cxx:1689
 AliAnalysisTaskVnV0.cxx:1690
 AliAnalysisTaskVnV0.cxx:1691
 AliAnalysisTaskVnV0.cxx:1692
 AliAnalysisTaskVnV0.cxx:1693
 AliAnalysisTaskVnV0.cxx:1694
 AliAnalysisTaskVnV0.cxx:1695
 AliAnalysisTaskVnV0.cxx:1696
 AliAnalysisTaskVnV0.cxx:1697
 AliAnalysisTaskVnV0.cxx:1698
 AliAnalysisTaskVnV0.cxx:1699
 AliAnalysisTaskVnV0.cxx:1700
 AliAnalysisTaskVnV0.cxx:1701
 AliAnalysisTaskVnV0.cxx:1702
 AliAnalysisTaskVnV0.cxx:1703
 AliAnalysisTaskVnV0.cxx:1704
 AliAnalysisTaskVnV0.cxx:1705
 AliAnalysisTaskVnV0.cxx:1706
 AliAnalysisTaskVnV0.cxx:1707
 AliAnalysisTaskVnV0.cxx:1708
 AliAnalysisTaskVnV0.cxx:1709
 AliAnalysisTaskVnV0.cxx:1710
 AliAnalysisTaskVnV0.cxx:1711
 AliAnalysisTaskVnV0.cxx:1712
 AliAnalysisTaskVnV0.cxx:1713
 AliAnalysisTaskVnV0.cxx:1714
 AliAnalysisTaskVnV0.cxx:1715
 AliAnalysisTaskVnV0.cxx:1716
 AliAnalysisTaskVnV0.cxx:1717
 AliAnalysisTaskVnV0.cxx:1718
 AliAnalysisTaskVnV0.cxx:1719
 AliAnalysisTaskVnV0.cxx:1720
 AliAnalysisTaskVnV0.cxx:1721
 AliAnalysisTaskVnV0.cxx:1722
 AliAnalysisTaskVnV0.cxx:1723
 AliAnalysisTaskVnV0.cxx:1724
 AliAnalysisTaskVnV0.cxx:1725
 AliAnalysisTaskVnV0.cxx:1726
 AliAnalysisTaskVnV0.cxx:1727
 AliAnalysisTaskVnV0.cxx:1728
 AliAnalysisTaskVnV0.cxx:1729
 AliAnalysisTaskVnV0.cxx:1730
 AliAnalysisTaskVnV0.cxx:1731
 AliAnalysisTaskVnV0.cxx:1732
 AliAnalysisTaskVnV0.cxx:1733
 AliAnalysisTaskVnV0.cxx:1734
 AliAnalysisTaskVnV0.cxx:1735
 AliAnalysisTaskVnV0.cxx:1736
 AliAnalysisTaskVnV0.cxx:1737
 AliAnalysisTaskVnV0.cxx:1738
 AliAnalysisTaskVnV0.cxx:1739
 AliAnalysisTaskVnV0.cxx:1740
 AliAnalysisTaskVnV0.cxx:1741
 AliAnalysisTaskVnV0.cxx:1742
 AliAnalysisTaskVnV0.cxx:1743
 AliAnalysisTaskVnV0.cxx:1744
 AliAnalysisTaskVnV0.cxx:1745
 AliAnalysisTaskVnV0.cxx:1746
 AliAnalysisTaskVnV0.cxx:1747
 AliAnalysisTaskVnV0.cxx:1748
 AliAnalysisTaskVnV0.cxx:1749
 AliAnalysisTaskVnV0.cxx:1750
 AliAnalysisTaskVnV0.cxx:1751
 AliAnalysisTaskVnV0.cxx:1752
 AliAnalysisTaskVnV0.cxx:1753
 AliAnalysisTaskVnV0.cxx:1754
 AliAnalysisTaskVnV0.cxx:1755
 AliAnalysisTaskVnV0.cxx:1756
 AliAnalysisTaskVnV0.cxx:1757
 AliAnalysisTaskVnV0.cxx:1758
 AliAnalysisTaskVnV0.cxx:1759
 AliAnalysisTaskVnV0.cxx:1760
 AliAnalysisTaskVnV0.cxx:1761
 AliAnalysisTaskVnV0.cxx:1762
 AliAnalysisTaskVnV0.cxx:1763
 AliAnalysisTaskVnV0.cxx:1764
 AliAnalysisTaskVnV0.cxx:1765
 AliAnalysisTaskVnV0.cxx:1766
 AliAnalysisTaskVnV0.cxx:1767
 AliAnalysisTaskVnV0.cxx:1768
 AliAnalysisTaskVnV0.cxx:1769
 AliAnalysisTaskVnV0.cxx:1770
 AliAnalysisTaskVnV0.cxx:1771
 AliAnalysisTaskVnV0.cxx:1772
 AliAnalysisTaskVnV0.cxx:1773
 AliAnalysisTaskVnV0.cxx:1774
 AliAnalysisTaskVnV0.cxx:1775
 AliAnalysisTaskVnV0.cxx:1776
 AliAnalysisTaskVnV0.cxx:1777
 AliAnalysisTaskVnV0.cxx:1778
 AliAnalysisTaskVnV0.cxx:1779
 AliAnalysisTaskVnV0.cxx:1780
 AliAnalysisTaskVnV0.cxx:1781
 AliAnalysisTaskVnV0.cxx:1782
 AliAnalysisTaskVnV0.cxx:1783
 AliAnalysisTaskVnV0.cxx:1784
 AliAnalysisTaskVnV0.cxx:1785
 AliAnalysisTaskVnV0.cxx:1786
 AliAnalysisTaskVnV0.cxx:1787
 AliAnalysisTaskVnV0.cxx:1788
 AliAnalysisTaskVnV0.cxx:1789
 AliAnalysisTaskVnV0.cxx:1790
 AliAnalysisTaskVnV0.cxx:1791
 AliAnalysisTaskVnV0.cxx:1792
 AliAnalysisTaskVnV0.cxx:1793
 AliAnalysisTaskVnV0.cxx:1794
 AliAnalysisTaskVnV0.cxx:1795
 AliAnalysisTaskVnV0.cxx:1796
 AliAnalysisTaskVnV0.cxx:1797
 AliAnalysisTaskVnV0.cxx:1798
 AliAnalysisTaskVnV0.cxx:1799
 AliAnalysisTaskVnV0.cxx:1800
 AliAnalysisTaskVnV0.cxx:1801
 AliAnalysisTaskVnV0.cxx:1802
 AliAnalysisTaskVnV0.cxx:1803
 AliAnalysisTaskVnV0.cxx:1804
 AliAnalysisTaskVnV0.cxx:1805
 AliAnalysisTaskVnV0.cxx:1806
 AliAnalysisTaskVnV0.cxx:1807
 AliAnalysisTaskVnV0.cxx:1808
 AliAnalysisTaskVnV0.cxx:1809
 AliAnalysisTaskVnV0.cxx:1810
 AliAnalysisTaskVnV0.cxx:1811
 AliAnalysisTaskVnV0.cxx:1812
 AliAnalysisTaskVnV0.cxx:1813
 AliAnalysisTaskVnV0.cxx:1814
 AliAnalysisTaskVnV0.cxx:1815
 AliAnalysisTaskVnV0.cxx:1816
 AliAnalysisTaskVnV0.cxx:1817
 AliAnalysisTaskVnV0.cxx:1818
 AliAnalysisTaskVnV0.cxx:1819
 AliAnalysisTaskVnV0.cxx:1820
 AliAnalysisTaskVnV0.cxx:1821
 AliAnalysisTaskVnV0.cxx:1822
 AliAnalysisTaskVnV0.cxx:1823
 AliAnalysisTaskVnV0.cxx:1824
 AliAnalysisTaskVnV0.cxx:1825
 AliAnalysisTaskVnV0.cxx:1826
 AliAnalysisTaskVnV0.cxx:1827
 AliAnalysisTaskVnV0.cxx:1828
 AliAnalysisTaskVnV0.cxx:1829
 AliAnalysisTaskVnV0.cxx:1830
 AliAnalysisTaskVnV0.cxx:1831
 AliAnalysisTaskVnV0.cxx:1832
 AliAnalysisTaskVnV0.cxx:1833
 AliAnalysisTaskVnV0.cxx:1834
 AliAnalysisTaskVnV0.cxx:1835
 AliAnalysisTaskVnV0.cxx:1836
 AliAnalysisTaskVnV0.cxx:1837
 AliAnalysisTaskVnV0.cxx:1838
 AliAnalysisTaskVnV0.cxx:1839
 AliAnalysisTaskVnV0.cxx:1840
 AliAnalysisTaskVnV0.cxx:1841
 AliAnalysisTaskVnV0.cxx:1842
 AliAnalysisTaskVnV0.cxx:1843
 AliAnalysisTaskVnV0.cxx:1844
 AliAnalysisTaskVnV0.cxx:1845
 AliAnalysisTaskVnV0.cxx:1846
 AliAnalysisTaskVnV0.cxx:1847
 AliAnalysisTaskVnV0.cxx:1848
 AliAnalysisTaskVnV0.cxx:1849
 AliAnalysisTaskVnV0.cxx:1850
 AliAnalysisTaskVnV0.cxx:1851
 AliAnalysisTaskVnV0.cxx:1852
 AliAnalysisTaskVnV0.cxx:1853
 AliAnalysisTaskVnV0.cxx:1854
 AliAnalysisTaskVnV0.cxx:1855
 AliAnalysisTaskVnV0.cxx:1856
 AliAnalysisTaskVnV0.cxx:1857
 AliAnalysisTaskVnV0.cxx:1858
 AliAnalysisTaskVnV0.cxx:1859
 AliAnalysisTaskVnV0.cxx:1860
 AliAnalysisTaskVnV0.cxx:1861
 AliAnalysisTaskVnV0.cxx:1862
 AliAnalysisTaskVnV0.cxx:1863
 AliAnalysisTaskVnV0.cxx:1864
 AliAnalysisTaskVnV0.cxx:1865
 AliAnalysisTaskVnV0.cxx:1866
 AliAnalysisTaskVnV0.cxx:1867
 AliAnalysisTaskVnV0.cxx:1868
 AliAnalysisTaskVnV0.cxx:1869
 AliAnalysisTaskVnV0.cxx:1870
 AliAnalysisTaskVnV0.cxx:1871
 AliAnalysisTaskVnV0.cxx:1872
 AliAnalysisTaskVnV0.cxx:1873
 AliAnalysisTaskVnV0.cxx:1874
 AliAnalysisTaskVnV0.cxx:1875
 AliAnalysisTaskVnV0.cxx:1876
 AliAnalysisTaskVnV0.cxx:1877
 AliAnalysisTaskVnV0.cxx:1878
 AliAnalysisTaskVnV0.cxx:1879
 AliAnalysisTaskVnV0.cxx:1880
 AliAnalysisTaskVnV0.cxx:1881
 AliAnalysisTaskVnV0.cxx:1882
 AliAnalysisTaskVnV0.cxx:1883
 AliAnalysisTaskVnV0.cxx:1884
 AliAnalysisTaskVnV0.cxx:1885
 AliAnalysisTaskVnV0.cxx:1886
 AliAnalysisTaskVnV0.cxx:1887
 AliAnalysisTaskVnV0.cxx:1888
 AliAnalysisTaskVnV0.cxx:1889
 AliAnalysisTaskVnV0.cxx:1890
 AliAnalysisTaskVnV0.cxx:1891
 AliAnalysisTaskVnV0.cxx:1892
 AliAnalysisTaskVnV0.cxx:1893
 AliAnalysisTaskVnV0.cxx:1894
 AliAnalysisTaskVnV0.cxx:1895
 AliAnalysisTaskVnV0.cxx:1896
 AliAnalysisTaskVnV0.cxx:1897
 AliAnalysisTaskVnV0.cxx:1898
 AliAnalysisTaskVnV0.cxx:1899
 AliAnalysisTaskVnV0.cxx:1900
 AliAnalysisTaskVnV0.cxx:1901
 AliAnalysisTaskVnV0.cxx:1902
 AliAnalysisTaskVnV0.cxx:1903
 AliAnalysisTaskVnV0.cxx:1904
 AliAnalysisTaskVnV0.cxx:1905
 AliAnalysisTaskVnV0.cxx:1906
 AliAnalysisTaskVnV0.cxx:1907
 AliAnalysisTaskVnV0.cxx:1908
 AliAnalysisTaskVnV0.cxx:1909
 AliAnalysisTaskVnV0.cxx:1910
 AliAnalysisTaskVnV0.cxx:1911
 AliAnalysisTaskVnV0.cxx:1912
 AliAnalysisTaskVnV0.cxx:1913
 AliAnalysisTaskVnV0.cxx:1914
 AliAnalysisTaskVnV0.cxx:1915
 AliAnalysisTaskVnV0.cxx:1916
 AliAnalysisTaskVnV0.cxx:1917
 AliAnalysisTaskVnV0.cxx:1918
 AliAnalysisTaskVnV0.cxx:1919
 AliAnalysisTaskVnV0.cxx:1920
 AliAnalysisTaskVnV0.cxx:1921
 AliAnalysisTaskVnV0.cxx:1922
 AliAnalysisTaskVnV0.cxx:1923
 AliAnalysisTaskVnV0.cxx:1924
 AliAnalysisTaskVnV0.cxx:1925
 AliAnalysisTaskVnV0.cxx:1926
 AliAnalysisTaskVnV0.cxx:1927
 AliAnalysisTaskVnV0.cxx:1928
 AliAnalysisTaskVnV0.cxx:1929
 AliAnalysisTaskVnV0.cxx:1930
 AliAnalysisTaskVnV0.cxx:1931
 AliAnalysisTaskVnV0.cxx:1932
 AliAnalysisTaskVnV0.cxx:1933
 AliAnalysisTaskVnV0.cxx:1934
 AliAnalysisTaskVnV0.cxx:1935
 AliAnalysisTaskVnV0.cxx:1936
 AliAnalysisTaskVnV0.cxx:1937
 AliAnalysisTaskVnV0.cxx:1938
 AliAnalysisTaskVnV0.cxx:1939
 AliAnalysisTaskVnV0.cxx:1940
 AliAnalysisTaskVnV0.cxx:1941
 AliAnalysisTaskVnV0.cxx:1942
 AliAnalysisTaskVnV0.cxx:1943
 AliAnalysisTaskVnV0.cxx:1944
 AliAnalysisTaskVnV0.cxx:1945
 AliAnalysisTaskVnV0.cxx:1946
 AliAnalysisTaskVnV0.cxx:1947
 AliAnalysisTaskVnV0.cxx:1948
 AliAnalysisTaskVnV0.cxx:1949
 AliAnalysisTaskVnV0.cxx:1950
 AliAnalysisTaskVnV0.cxx:1951
 AliAnalysisTaskVnV0.cxx:1952
 AliAnalysisTaskVnV0.cxx:1953
 AliAnalysisTaskVnV0.cxx:1954
 AliAnalysisTaskVnV0.cxx:1955
 AliAnalysisTaskVnV0.cxx:1956
 AliAnalysisTaskVnV0.cxx:1957
 AliAnalysisTaskVnV0.cxx:1958
 AliAnalysisTaskVnV0.cxx:1959
 AliAnalysisTaskVnV0.cxx:1960
 AliAnalysisTaskVnV0.cxx:1961
 AliAnalysisTaskVnV0.cxx:1962
 AliAnalysisTaskVnV0.cxx:1963
 AliAnalysisTaskVnV0.cxx:1964
 AliAnalysisTaskVnV0.cxx:1965
 AliAnalysisTaskVnV0.cxx:1966
 AliAnalysisTaskVnV0.cxx:1967
 AliAnalysisTaskVnV0.cxx:1968
 AliAnalysisTaskVnV0.cxx:1969
 AliAnalysisTaskVnV0.cxx:1970
 AliAnalysisTaskVnV0.cxx:1971
 AliAnalysisTaskVnV0.cxx:1972
 AliAnalysisTaskVnV0.cxx:1973
 AliAnalysisTaskVnV0.cxx:1974
 AliAnalysisTaskVnV0.cxx:1975
 AliAnalysisTaskVnV0.cxx:1976
 AliAnalysisTaskVnV0.cxx:1977
 AliAnalysisTaskVnV0.cxx:1978
 AliAnalysisTaskVnV0.cxx:1979
 AliAnalysisTaskVnV0.cxx:1980
 AliAnalysisTaskVnV0.cxx:1981
 AliAnalysisTaskVnV0.cxx:1982
 AliAnalysisTaskVnV0.cxx:1983
 AliAnalysisTaskVnV0.cxx:1984
 AliAnalysisTaskVnV0.cxx:1985
 AliAnalysisTaskVnV0.cxx:1986
 AliAnalysisTaskVnV0.cxx:1987
 AliAnalysisTaskVnV0.cxx:1988
 AliAnalysisTaskVnV0.cxx:1989
 AliAnalysisTaskVnV0.cxx:1990
 AliAnalysisTaskVnV0.cxx:1991
 AliAnalysisTaskVnV0.cxx:1992
 AliAnalysisTaskVnV0.cxx:1993
 AliAnalysisTaskVnV0.cxx:1994
 AliAnalysisTaskVnV0.cxx:1995
 AliAnalysisTaskVnV0.cxx:1996
 AliAnalysisTaskVnV0.cxx:1997
 AliAnalysisTaskVnV0.cxx:1998
 AliAnalysisTaskVnV0.cxx:1999
 AliAnalysisTaskVnV0.cxx:2000
 AliAnalysisTaskVnV0.cxx:2001
 AliAnalysisTaskVnV0.cxx:2002
 AliAnalysisTaskVnV0.cxx:2003
 AliAnalysisTaskVnV0.cxx:2004
 AliAnalysisTaskVnV0.cxx:2005
 AliAnalysisTaskVnV0.cxx:2006
 AliAnalysisTaskVnV0.cxx:2007
 AliAnalysisTaskVnV0.cxx:2008
 AliAnalysisTaskVnV0.cxx:2009
 AliAnalysisTaskVnV0.cxx:2010
 AliAnalysisTaskVnV0.cxx:2011
 AliAnalysisTaskVnV0.cxx:2012
 AliAnalysisTaskVnV0.cxx:2013
 AliAnalysisTaskVnV0.cxx:2014
 AliAnalysisTaskVnV0.cxx:2015
 AliAnalysisTaskVnV0.cxx:2016
 AliAnalysisTaskVnV0.cxx:2017
 AliAnalysisTaskVnV0.cxx:2018
 AliAnalysisTaskVnV0.cxx:2019
 AliAnalysisTaskVnV0.cxx:2020
 AliAnalysisTaskVnV0.cxx:2021
 AliAnalysisTaskVnV0.cxx:2022
 AliAnalysisTaskVnV0.cxx:2023
 AliAnalysisTaskVnV0.cxx:2024
 AliAnalysisTaskVnV0.cxx:2025
 AliAnalysisTaskVnV0.cxx:2026
 AliAnalysisTaskVnV0.cxx:2027
 AliAnalysisTaskVnV0.cxx:2028
 AliAnalysisTaskVnV0.cxx:2029
 AliAnalysisTaskVnV0.cxx:2030
 AliAnalysisTaskVnV0.cxx:2031
 AliAnalysisTaskVnV0.cxx:2032
 AliAnalysisTaskVnV0.cxx:2033
 AliAnalysisTaskVnV0.cxx:2034
 AliAnalysisTaskVnV0.cxx:2035
 AliAnalysisTaskVnV0.cxx:2036
 AliAnalysisTaskVnV0.cxx:2037
 AliAnalysisTaskVnV0.cxx:2038
 AliAnalysisTaskVnV0.cxx:2039
 AliAnalysisTaskVnV0.cxx:2040
 AliAnalysisTaskVnV0.cxx:2041
 AliAnalysisTaskVnV0.cxx:2042
 AliAnalysisTaskVnV0.cxx:2043
 AliAnalysisTaskVnV0.cxx:2044
 AliAnalysisTaskVnV0.cxx:2045
 AliAnalysisTaskVnV0.cxx:2046
 AliAnalysisTaskVnV0.cxx:2047
 AliAnalysisTaskVnV0.cxx:2048
 AliAnalysisTaskVnV0.cxx:2049
 AliAnalysisTaskVnV0.cxx:2050
 AliAnalysisTaskVnV0.cxx:2051
 AliAnalysisTaskVnV0.cxx:2052
 AliAnalysisTaskVnV0.cxx:2053
 AliAnalysisTaskVnV0.cxx:2054
 AliAnalysisTaskVnV0.cxx:2055
 AliAnalysisTaskVnV0.cxx:2056
 AliAnalysisTaskVnV0.cxx:2057
 AliAnalysisTaskVnV0.cxx:2058
 AliAnalysisTaskVnV0.cxx:2059
 AliAnalysisTaskVnV0.cxx:2060
 AliAnalysisTaskVnV0.cxx:2061
 AliAnalysisTaskVnV0.cxx:2062
 AliAnalysisTaskVnV0.cxx:2063
 AliAnalysisTaskVnV0.cxx:2064
 AliAnalysisTaskVnV0.cxx:2065
 AliAnalysisTaskVnV0.cxx:2066
 AliAnalysisTaskVnV0.cxx:2067
 AliAnalysisTaskVnV0.cxx:2068
 AliAnalysisTaskVnV0.cxx:2069
 AliAnalysisTaskVnV0.cxx:2070
 AliAnalysisTaskVnV0.cxx:2071
 AliAnalysisTaskVnV0.cxx:2072
 AliAnalysisTaskVnV0.cxx:2073
 AliAnalysisTaskVnV0.cxx:2074
 AliAnalysisTaskVnV0.cxx:2075
 AliAnalysisTaskVnV0.cxx:2076
 AliAnalysisTaskVnV0.cxx:2077
 AliAnalysisTaskVnV0.cxx:2078
 AliAnalysisTaskVnV0.cxx:2079
 AliAnalysisTaskVnV0.cxx:2080
 AliAnalysisTaskVnV0.cxx:2081
 AliAnalysisTaskVnV0.cxx:2082
 AliAnalysisTaskVnV0.cxx:2083
 AliAnalysisTaskVnV0.cxx:2084
 AliAnalysisTaskVnV0.cxx:2085
 AliAnalysisTaskVnV0.cxx:2086
 AliAnalysisTaskVnV0.cxx:2087
 AliAnalysisTaskVnV0.cxx:2088
 AliAnalysisTaskVnV0.cxx:2089
 AliAnalysisTaskVnV0.cxx:2090
 AliAnalysisTaskVnV0.cxx:2091
 AliAnalysisTaskVnV0.cxx:2092
 AliAnalysisTaskVnV0.cxx:2093
 AliAnalysisTaskVnV0.cxx:2094
 AliAnalysisTaskVnV0.cxx:2095
 AliAnalysisTaskVnV0.cxx:2096
 AliAnalysisTaskVnV0.cxx:2097
 AliAnalysisTaskVnV0.cxx:2098
 AliAnalysisTaskVnV0.cxx:2099
 AliAnalysisTaskVnV0.cxx:2100
 AliAnalysisTaskVnV0.cxx:2101
 AliAnalysisTaskVnV0.cxx:2102
 AliAnalysisTaskVnV0.cxx:2103
 AliAnalysisTaskVnV0.cxx:2104
 AliAnalysisTaskVnV0.cxx:2105
 AliAnalysisTaskVnV0.cxx:2106
 AliAnalysisTaskVnV0.cxx:2107
 AliAnalysisTaskVnV0.cxx:2108
 AliAnalysisTaskVnV0.cxx:2109
 AliAnalysisTaskVnV0.cxx:2110
 AliAnalysisTaskVnV0.cxx:2111
 AliAnalysisTaskVnV0.cxx:2112
 AliAnalysisTaskVnV0.cxx:2113
 AliAnalysisTaskVnV0.cxx:2114
 AliAnalysisTaskVnV0.cxx:2115
 AliAnalysisTaskVnV0.cxx:2116
 AliAnalysisTaskVnV0.cxx:2117
 AliAnalysisTaskVnV0.cxx:2118
 AliAnalysisTaskVnV0.cxx:2119
 AliAnalysisTaskVnV0.cxx:2120
 AliAnalysisTaskVnV0.cxx:2121
 AliAnalysisTaskVnV0.cxx:2122
 AliAnalysisTaskVnV0.cxx:2123
 AliAnalysisTaskVnV0.cxx:2124
 AliAnalysisTaskVnV0.cxx:2125
 AliAnalysisTaskVnV0.cxx:2126
 AliAnalysisTaskVnV0.cxx:2127
 AliAnalysisTaskVnV0.cxx:2128
 AliAnalysisTaskVnV0.cxx:2129
 AliAnalysisTaskVnV0.cxx:2130
 AliAnalysisTaskVnV0.cxx:2131
 AliAnalysisTaskVnV0.cxx:2132
 AliAnalysisTaskVnV0.cxx:2133
 AliAnalysisTaskVnV0.cxx:2134
 AliAnalysisTaskVnV0.cxx:2135
 AliAnalysisTaskVnV0.cxx:2136
 AliAnalysisTaskVnV0.cxx:2137
 AliAnalysisTaskVnV0.cxx:2138
 AliAnalysisTaskVnV0.cxx:2139
 AliAnalysisTaskVnV0.cxx:2140
 AliAnalysisTaskVnV0.cxx:2141
 AliAnalysisTaskVnV0.cxx:2142
 AliAnalysisTaskVnV0.cxx:2143
 AliAnalysisTaskVnV0.cxx:2144
 AliAnalysisTaskVnV0.cxx:2145
 AliAnalysisTaskVnV0.cxx:2146
 AliAnalysisTaskVnV0.cxx:2147
 AliAnalysisTaskVnV0.cxx:2148
 AliAnalysisTaskVnV0.cxx:2149
 AliAnalysisTaskVnV0.cxx:2150
 AliAnalysisTaskVnV0.cxx:2151
 AliAnalysisTaskVnV0.cxx:2152
 AliAnalysisTaskVnV0.cxx:2153
 AliAnalysisTaskVnV0.cxx:2154
 AliAnalysisTaskVnV0.cxx:2155
 AliAnalysisTaskVnV0.cxx:2156
 AliAnalysisTaskVnV0.cxx:2157
 AliAnalysisTaskVnV0.cxx:2158
 AliAnalysisTaskVnV0.cxx:2159
 AliAnalysisTaskVnV0.cxx:2160
 AliAnalysisTaskVnV0.cxx:2161
 AliAnalysisTaskVnV0.cxx:2162
 AliAnalysisTaskVnV0.cxx:2163
 AliAnalysisTaskVnV0.cxx:2164
 AliAnalysisTaskVnV0.cxx:2165
 AliAnalysisTaskVnV0.cxx:2166
 AliAnalysisTaskVnV0.cxx:2167
 AliAnalysisTaskVnV0.cxx:2168
 AliAnalysisTaskVnV0.cxx:2169
 AliAnalysisTaskVnV0.cxx:2170
 AliAnalysisTaskVnV0.cxx:2171
 AliAnalysisTaskVnV0.cxx:2172
 AliAnalysisTaskVnV0.cxx:2173
 AliAnalysisTaskVnV0.cxx:2174
 AliAnalysisTaskVnV0.cxx:2175
 AliAnalysisTaskVnV0.cxx:2176
 AliAnalysisTaskVnV0.cxx:2177
 AliAnalysisTaskVnV0.cxx:2178
 AliAnalysisTaskVnV0.cxx:2179
 AliAnalysisTaskVnV0.cxx:2180
 AliAnalysisTaskVnV0.cxx:2181
 AliAnalysisTaskVnV0.cxx:2182
 AliAnalysisTaskVnV0.cxx:2183
 AliAnalysisTaskVnV0.cxx:2184
 AliAnalysisTaskVnV0.cxx:2185
 AliAnalysisTaskVnV0.cxx:2186
 AliAnalysisTaskVnV0.cxx:2187
 AliAnalysisTaskVnV0.cxx:2188
 AliAnalysisTaskVnV0.cxx:2189
 AliAnalysisTaskVnV0.cxx:2190
 AliAnalysisTaskVnV0.cxx:2191
 AliAnalysisTaskVnV0.cxx:2192
 AliAnalysisTaskVnV0.cxx:2193
 AliAnalysisTaskVnV0.cxx:2194
 AliAnalysisTaskVnV0.cxx:2195
 AliAnalysisTaskVnV0.cxx:2196
 AliAnalysisTaskVnV0.cxx:2197
 AliAnalysisTaskVnV0.cxx:2198
 AliAnalysisTaskVnV0.cxx:2199
 AliAnalysisTaskVnV0.cxx:2200
 AliAnalysisTaskVnV0.cxx:2201
 AliAnalysisTaskVnV0.cxx:2202
 AliAnalysisTaskVnV0.cxx:2203
 AliAnalysisTaskVnV0.cxx:2204
 AliAnalysisTaskVnV0.cxx:2205
 AliAnalysisTaskVnV0.cxx:2206
 AliAnalysisTaskVnV0.cxx:2207
 AliAnalysisTaskVnV0.cxx:2208
 AliAnalysisTaskVnV0.cxx:2209
 AliAnalysisTaskVnV0.cxx:2210
 AliAnalysisTaskVnV0.cxx:2211
 AliAnalysisTaskVnV0.cxx:2212
 AliAnalysisTaskVnV0.cxx:2213
 AliAnalysisTaskVnV0.cxx:2214
 AliAnalysisTaskVnV0.cxx:2215
 AliAnalysisTaskVnV0.cxx:2216
 AliAnalysisTaskVnV0.cxx:2217
 AliAnalysisTaskVnV0.cxx:2218
 AliAnalysisTaskVnV0.cxx:2219
 AliAnalysisTaskVnV0.cxx:2220
 AliAnalysisTaskVnV0.cxx:2221
 AliAnalysisTaskVnV0.cxx:2222
 AliAnalysisTaskVnV0.cxx:2223
 AliAnalysisTaskVnV0.cxx:2224
 AliAnalysisTaskVnV0.cxx:2225
 AliAnalysisTaskVnV0.cxx:2226
 AliAnalysisTaskVnV0.cxx:2227
 AliAnalysisTaskVnV0.cxx:2228
 AliAnalysisTaskVnV0.cxx:2229
 AliAnalysisTaskVnV0.cxx:2230
 AliAnalysisTaskVnV0.cxx:2231
 AliAnalysisTaskVnV0.cxx:2232
 AliAnalysisTaskVnV0.cxx:2233
 AliAnalysisTaskVnV0.cxx:2234
 AliAnalysisTaskVnV0.cxx:2235
 AliAnalysisTaskVnV0.cxx:2236
 AliAnalysisTaskVnV0.cxx:2237