ROOT logo
#include "CommonDefs.C"

enum EMCHisto_t {
  kPrimary,
  kWeakDecay,
  kMaterial,
  kNMCHistos
};
const Char_t *mchistoName[kNMCHistos] = {
  "primary",
  "weakdecay",
  "material"
};

DCAdata(const Char_t *filename, Int_t evMax = kMaxInt, Int_t startEv = 0)
{
  
  /* include path for ACLic */
  gSystem->AddIncludePath("-I$ALICE_ROOT/include");
  gSystem->AddIncludePath("-I$ALICE_ROOT/TOF");
  /* load libraries */
  gSystem->Load("libANALYSIS");
  gSystem->Load("libANALYSISalice");
  /* build analysis task class */
  gROOT->LoadMacro("AliAnalysisParticle.cxx+g");
  gROOT->LoadMacro("AliAnalysisEvent.cxx+g");
  gROOT->LoadMacro("AliAnalysisTrack.cxx+g");

  /* open file, get tree and connect */
  TFile *filein = TFile::Open(filename);
  TTree *treein = (TTree *)filein->Get("aodTree");
  printf("got \"aodTree\": %d entries\n", treein->GetEntries());
  AliAnalysisEvent *analysisEvent = new AliAnalysisEvent();
  TClonesArray *analysisTrackArray = new TClonesArray("AliAnalysisTrack");
  AliAnalysisTrack *analysisTrack = NULL;
  treein->SetBranchAddress("AnalysisEvent", &analysisEvent);
  treein->SetBranchAddress("AnalysisTrack", &analysisTrackArray);

  /* open enabled flag map */
  TH1F *hEnabledFlag = NULL;
  if (enabledChannelsFileName) {
    TFile *enabledfile = TFile::Open(enabledChannelsFileName);
    hEnabledFlag = (TH1F *)enabledfile->Get("hEnabledFlag");
  }

  /**************************************************************/
  /*** HISTOS ***************************************************/
  /**************************************************************/

  /* run-time binning */
  for (Int_t ibin = 0; ibin < NdcaBins + 1; ibin++)
    dcaBin[ibin] = dcaMin + ibin * dcaStep;
  
  /* histos */
  TH3I *hDCAopen[AliPID::kSPECIES][kNCharges];
  TH3I *hDCAcut[AliPID::kSPECIES][kNCharges];
  for (Int_t ipart = 0; ipart < AliPID::kSPECIES; ipart++) {
    for (Int_t icharge = 0; icharge < kNCharges; icharge++) {
      hDCAopen[ipart][icharge] = new TH3I(Form("hDCAopen_%s_%s", AliPID::ParticleName(ipart), chargeName[icharge]), "", NcentralityBins, centralityBin, NptBins, ptBin, NdcaBins, dcaBin);
      hDCAcut[ipart][icharge] = new TH3I(Form("hDCAcut_%s_%s", AliPID::ParticleName(ipart), chargeName[icharge]), "", NcentralityBins, centralityBin, NptBins, ptBin, NdcaBins, dcaBin);
    }
  }
  
  /**************************************************************/
  /**************************************************************/
  /**************************************************************/

  /* TOF PID response */
  AliTOFPIDResponse tofResponse;
  tofResponse.SetTimeResolution(tofReso);
  /* TPC PID response */
  AliTPCPIDResponse *tpcResponse = AliAnalysisTrack::GetTPCResponse();

  /* start stopwatch */
  TStopwatch timer;
  timer.Start();

  /* loop over events */
  Int_t charge, index;
  UShort_t dedxN;
  Double_t cent, p, pt, mt, dca, tofsignal, tpcsignal, tpctofsignal;
  Double_t dedx, bethe, deltadedx, dedx_sigma, ptpc;
  Double_t time, time_sigma, timezero, timezero_sigma, tof, tof_sigma, texp, texp_sigma, deltat, deltat_sigma;

  /* open TZERO calibfile */
  TH1 *hCentrality_TZEROA_mean = NULL;
  TH1 *hCentrality_TZEROA_sigma = NULL;
  TH1 *hCentrality_TZEROC_mean = NULL;
  TH1 *hCentrality_TZEROC_sigma = NULL;
  TH1 *hCentrality_TOF_mean = NULL;
  TH1 *hCentrality_TOF_TZEROA_mean = NULL;
  TH1 *hCentrality_TOF_TZEROC_mean = NULL;
  TH1 *hCentrality_TOF_TZEROTOF_mean = NULL;
  TH1 *hCentrality_TZEROA_reso = NULL;
  TH1 *hCentrality_TZEROC_reso = NULL;
  TH1 *hCentrality_TZEROAND_reso = NULL;
  if (1) {
    TFile *calibfile = TFile::Open("TZEROcalibration.root");
    hCentrality_TZEROA_mean = (TH1 *)calibfile->Get("hCentrality_TZEROA_mean");
    hCentrality_TZEROA_sigma = (TH1 *)calibfile->Get("hCentrality_TZEROA_sigma");
    hCentrality_TZEROC_mean = (TH1 *)calibfile->Get("hCentrality_TZEROC_calib");
    hCentrality_TZEROC_sigma = (TH1 *)calibfile->Get("hCentrality_TZEROC_sigma");
    hCentrality_TOF_mean = (TH1 *)calibfile->Get("hCentrality_TOF_mean");
    hCentrality_TOF_TZEROA_mean = (TH1 *)calibfile->Get("hCentrality_TOF_TZEROA_mean");
    hCentrality_TOF_TZEROC_mean = (TH1 *)calibfile->Get("hCentrality_TOF_TZEROC_mean");
    hCentrality_TOF_TZEROTOF_mean = (TH1 *)calibfile->Get("hCentrality_TOF_TZEROTOF_mean");
  
    TFile *resofile = TFile::Open("TZEROresolution.root");
    hCentrality_TZEROA_reso = (TH1 *)resofile->Get("hTZEROA_reso");
    hCentrality_TZEROC_reso = (TH1 *)resofile->Get("hTZEROC_reso");
    hCentrality_TZEROAND_reso = (TH1 *)resofile->Get("hTZEROAND_reso");
  }
  Double_t TZEROA_mean;
  Double_t TZEROA_sigma;
  Double_t TZEROC_mean;
  Double_t TZEROC_sigma;
  Double_t TOF_mean;
  Double_t TOF_TZEROA_mean;
  Double_t TOF_TZEROC_mean;
  Double_t TOF_TZEROTOF_mean;
  Double_t TZEROA;
  Double_t TZEROA_reso;
  Bool_t hasTZEROA;
  Double_t TZEROC;
  Double_t TZEROC_reso;
  Bool_t hasTZEROC;
  Double_t TZEROAND;
  Double_t TZEROAND_reso;
  Bool_t hasTZEROAND;
  Double_t TZEROTOF;
  Double_t TZEROTOF_reso;
  Bool_t hasTZEROTOF;
  Double_t TZEROMEAN;
  Double_t TZEROMEAN_weight;
  Double_t TZEROBEST;
  Double_t TZEROBEST_reso;


  for (Int_t iev = startEv; iev < treein->GetEntries() && iev < evMax; iev++) {
    /* get event */
    treein->GetEvent(iev);
    if (iev % 100000 == 0) printf("iev = %d\n", iev);
    /* check event */
    if (!analysisEvent->AcceptEvent(acceptEventType)) continue;

    /*** ACCEPTED EVENT ***/

    /* apply time-zero TOF correction */
    analysisEvent->ApplyTimeZeroTOFCorrection();

    /* get centrality */
    cent = analysisEvent->GetCentralityPercentile(centralityEstimator);

    /* TZERO corrections */
    Int_t icent;
    for (icent = 0; icent < NcentralityBins; icent++)
      if (cent < centralityBin[icent + 1])
	break;
    TZEROA_mean = hCentrality_TZEROA_mean ? hCentrality_TZEROA_mean->GetBinContent(icent + 1) : 0.;
    TZEROA_sigma = hCentrality_TZEROA_sigma ? hCentrality_TZEROA_sigma->GetBinContent(icent + 1) : 1000.;
    TZEROC_mean  = hCentrality_TZEROC_mean ? hCentrality_TZEROC_mean->GetBinContent(icent + 1) : 0.;
    TZEROC_sigma = hCentrality_TZEROC_sigma ? hCentrality_TZEROC_sigma->GetBinContent(icent + 1) : 1000.;
    
    TOF_mean = hCentrality_TOF_mean ? hCentrality_TOF_mean->GetBinContent(icent + 1) : 0.;
    TOF_TZEROA_mean = hCentrality_TOF_TZEROA_mean ? hCentrality_TOF_TZEROA_mean->GetBinContent(icent + 1) : 0.;
    TOF_TZEROC_mean = hCentrality_TOF_TZEROC_mean ? hCentrality_TOF_TZEROC_mean->GetBinContent(icent + 1) : 0.;
    TOF_TZEROTOF_mean = hCentrality_TOF_TZEROTOF_mean ? hCentrality_TOF_TZEROTOF_mean->GetBinContent(icent + 1) : 0.;
    
    TZEROA_reso = hCentrality_TZEROA_reso ? hCentrality_TZEROA_reso->GetBinContent(icent + 1) : 70.;
    TZEROC_reso = hCentrality_TZEROC_reso ? hCentrality_TZEROC_reso->GetBinContent(icent + 1) : 70.;
    TZEROAND_reso = hCentrality_TZEROAND_reso ? hCentrality_TZEROAND_reso->GetBinContent(icent + 1) : 50.;

    /* loop over tracks */
    for (Int_t itrk = 0; itrk < analysisTrackArray->GetEntries(); itrk++) {
      /* get track */
      analysisTrack = (AliAnalysisTrack *)analysisTrackArray->At(itrk);
      if (!analysisTrack) continue;
      /* check accepted track (no DCA cut) */
      if (!analysisTrack->AcceptTrack(kFALSE)) continue;
      /* get charge */
      charge = analysisTrack->GetSign() > 0. ? kPositive : kNegative;
      /* check TPC pid */
      if (!analysisTrack->HasTPCPID()) continue;
      /* check TOF pid */
      if (!analysisTrack->HasTOFPID(hEnabledFlag)) continue;

      /*** ACCEPTED TRACK WITH TPC+TOF PID ***/

      /* get track info */
      p = analysisTrack->GetP();
      pt = analysisTrack->GetPt();
      dca = analysisTrack->GetImpactParameter(0);

      /* get TPC info */
      dedx = analysisTrack->GetTPCdEdx();
      dedxN = analysisTrack->GetTPCdEdxN();
      ptpc = analysisTrack->GetTPCmomentum();
      
      /* apply expected time correction */
      //      analysisTrack->ApplyTOFExpectedTimeCorrection();
      
      /* get TOF info */
      time = analysisTrack->GetTOFTime() - TOF_mean;
      time_sigma = tofReso;
      /* TZEROTOF */
      TZEROTOF = analysisEvent->GetTimeZeroTOF(analysisTrack->GetP());
      TZEROTOF_reso = analysisEvent->GetTimeZeroTOFSigma(analysisTrack->GetP());
      hasTZEROTOF = TZEROTOF_reso < 150.;
      if (hasTZEROTOF) {
	TZEROTOF += TOF_TZEROTOF_mean - TOF_mean;
	TZEROTOF_reso *= TZEROTOF_resoScaleFactor;
      }
      /* TZEROA */
      TZEROA = analysisEvent->GetTimeZeroT0(1) - TZEROA_shift;
      //      TZEROA_reso = TZEROA_resolution[icent];
      hasTZEROA = TMath::Abs(TZEROA - TZEROA_mean) < 3. * TZEROA_sigma;
      TZEROA += TOF_TZEROA_mean - TOF_mean;
      /* TZEROC */
      TZEROC = analysisEvent->GetTimeZeroT0(2) - TZEROC_shift;
      //      TZEROC_reso = TZEROC_resolution[icent];
      hasTZEROC = TMath::Abs(TZEROC - TZEROC_mean) < 3. * TZEROC_sigma;
      TZEROC += TOF_TZEROC_mean - TOF_mean;
      /* TZEROAND */
      TZEROAND = (TZEROA + TZEROC) * 0.5;
      //      TZEROAND_reso = TZEROAND_resolution[icent];
      hasTZEROAND = hasTZEROA && hasTZEROC;
      /* TZEROMEAN */
      TZEROMEAN = TZEROTOF / TZEROTOF_reso / TZEROTOF_reso;
      TZEROMEAN_weight = 1. / TZEROTOF_reso / TZEROTOF_reso;
      if (hasTZEROAND) {
	//	printf("TZEROAND\n");
	TZEROMEAN += TZEROAND / TZEROAND_reso / TZEROAND_reso;
	TZEROMEAN_weight = 1. / TZEROAND_reso / TZEROAND_reso;
      }
      else if (hasTZEROA) {
	//	printf("TZEROA\n");
	TZEROMEAN += TZEROA / TZEROA_reso / TZEROA_reso;
	TZEROMEAN_weight = 1. / TZEROA_reso / TZEROA_reso;
      }
      else if (hasTZEROC) {
	//	printf("TZEROC\n");
	TZEROMEAN += TZEROC / TZEROC_reso / TZEROC_reso;
	TZEROMEAN_weight = 1. / TZEROC_reso / TZEROC_reso;
      }
      timezero = TZEROMEAN / TZEROMEAN_weight;
      timezero_sigma = TMath::Sqrt(1. / TZEROMEAN_weight);
      /* TZEROBEST */
      TZEROBEST = TZEROTOF;
      TZEROBEST_reso = TZEROTOF_reso;
      if (hasTZEROAND && TZEROAND_reso < TZEROBEST_reso) {
	TZEROBEST = TZEROAND;
	TZEROBEST_reso = TZEROAND_reso;
      }
      else if (hasTZEROA && TZEROA_reso < TZEROBEST_reso) {
	TZEROBEST = TZEROA;
	TZEROBEST_reso = TZEROA_reso;
      }
      if (hasTZEROC && TZEROC_reso < TZEROBEST_reso) {
	TZEROBEST = TZEROC;
	TZEROBEST_reso = TZEROC_reso;
      }
      timezero = TZEROBEST;
      timezero_sigma = TZEROBEST_reso;

      tof = time - timezero;
      tof_sigma = TMath::Sqrt(time_sigma * time_sigma + timezero_sigma * timezero_sigma);
      
      /* loop over particle IDs */
      for (Int_t ipart = 0; ipart < AliPID::kSPECIES; ipart++) {
	
	/* check rapidity */
	if (analysisTrack->GetY(AliPID::ParticleMass(ipart)) - rapidityShift > rapidityMaxCut || 
	    analysisTrack->GetY(AliPID::ParticleMass(ipart)) - rapidityShift < rapidityMinCut) continue;

	/*** ACCEPTED TRACK WITHIN CORRECT RAPIDTY ***/
	
	/* TPC signal */
	bethe = tpcResponse->GetExpectedSignal(ptpc, ipart);
	deltadedx = dedx - bethe;
	dedx_sigma = tpcResponse->GetExpectedSigma(ptpc, dedxN, ipart);
	tpcsignal = deltadedx / dedx_sigma;
	
	/* TOF expected time */
	texp = analysisTrack->GetTOFExpTime(ipart);
	texp_sigma = analysisTrack->GetTOFExpTimeSigma(ipart);
	
	/* TOF signal */
	deltat = tof - texp;
	deltat_sigma = TMath::Sqrt(tof_sigma * tof_sigma + texp_sigma * texp_sigma);
	tofsignal = deltat / deltat_sigma;
	
	/* TPC+TOF signal */
	tpctofsignal = TMath::Sqrt(tpcsignal * tpcsignal + tofsignal * tofsignal);

	/* check PID cuts */
	if (tpctofsignal > 2.) continue;

	/* fill histo */
	hDCAopen[ipart][charge]->Fill(cent, pt, dca);

	/* check accepted track (with DCA cut) */
	if (!analysisTrack->AcceptTrack(kTRUE)) continue;

	/* fill histo */
	hDCAcut[ipart][charge]->Fill(cent, pt, dca);
	
      } /* end of loop over particle IDs */
    } /* end of loop over tracks */
  } /* end of loop over events */
  
  /* stop stopwatch */
  timer.Stop();
  timer.Print();
  
  /* output */
  TFile *fileout = TFile::Open(Form("DCAdata.%s", filename), "RECREATE");
  for (Int_t ipart = 0; ipart < AliPID::kSPECIES; ipart++) {
    for (Int_t icharge = 0; icharge < kNCharges; icharge++) {
      hDCAopen[ipart][icharge]->Write();
      hDCAcut[ipart][icharge]->Write();
    }
  }

  fileout->Close();
  
}

/**************************************************************/

DCAmc(const Char_t *filename, Int_t evMax = kMaxInt, Int_t startEv = 0)
{
  
  /* include path for ACLic */
  gSystem->AddIncludePath("-I$ALICE_ROOT/include");
  gSystem->AddIncludePath("-I$ALICE_ROOT/TOF");
  /* load libraries */
  gSystem->Load("libANALYSIS");
  gSystem->Load("libANALYSISalice");
  /* build analysis task class */
  gROOT->LoadMacro("AliAnalysisParticle.cxx+g");
  gROOT->LoadMacro("AliAnalysisEvent.cxx+g");
  gROOT->LoadMacro("AliAnalysisTrack.cxx+g");

  /* open file, get tree and connect */
  TFile *filein = TFile::Open(filename);
  TTree *treein = (TTree *)filein->Get("aodTree");
  printf("got \"aodTree\": %d entries\n", treein->GetEntries());
  AliAnalysisEvent *analysisEvent = new AliAnalysisEvent();
  TClonesArray *analysisTrackArray = new TClonesArray("AliAnalysisTrack");
  AliAnalysisTrack *analysisTrack = NULL;
  treein->SetBranchAddress("AnalysisEvent", &analysisEvent);
  treein->SetBranchAddress("AnalysisTrack", &analysisTrackArray);

  /**************************************************************/
  /*** HISTOS ***************************************************/
  /**************************************************************/

  /* run-time binning */
  for (Int_t ibin = 0; ibin < NdcaBins + 1; ibin++)
    dcaBin[ibin] = dcaMin + ibin * dcaStep;
  
  /* histos */
  TH3I *hDCAopen[kNMCHistos][AliPID::kSPECIES][kNCharges];
  TH3I *hDCAcut[kNMCHistos][AliPID::kSPECIES][kNCharges];
  for (Int_t ihisto = 0; ihisto < kNMCHistos; ihisto++ ) {
    for (Int_t ipart = 0; ipart < AliPID::kSPECIES; ipart++) {
      for (Int_t icharge = 0; icharge < kNCharges; icharge++) {
	hDCAopen[ihisto][ipart][icharge] = new TH3I(Form("hDCAopen_%s_%s_%s", mchistoName[ihisto], AliPID::ParticleName(ipart), chargeName[icharge]), "", NcentralityBins, centralityBin, NptBins, ptBin, NdcaBins, dcaBin);
	hDCAcut[ihisto][ipart][icharge] = new TH3I(Form("hDCAcut_%s_%s_%s", mchistoName[ihisto], AliPID::ParticleName(ipart), chargeName[icharge]), "", NcentralityBins, centralityBin, NptBins, ptBin, NdcaBins, dcaBin);
      }
    }
  }
  
  /**************************************************************/
  /**************************************************************/
  /**************************************************************/

  /* start stopwatch */
  TStopwatch timer;
  timer.Start();

  /* loop over events */
  Int_t part, charge, type;
  Double_t cent, pt, mt, dca;

  for (Int_t iev = startEv; iev < treein->GetEntries() && iev < evMax; iev++) {
    /* get event */
    treein->GetEvent(iev);
    if (iev % 100000 == 0) printf("iev = %d\n", iev);
    /* check event */
    if (!analysisEvent->AcceptEvent(acceptEventType)) continue;

    /*** ACCEPTED EVENT ***/

    /* get centrality */
    cent = analysisEvent->GetCentralityPercentile(centralityEstimator);

    /* loop over tracks */
    for (Int_t itrk = 0; itrk < analysisTrackArray->GetEntries(); itrk++) {
      /* get track */
      analysisTrack = (AliAnalysisTrack *)analysisTrackArray->At(itrk);
      if (!analysisTrack) continue;
      /* check defined PID */
      part = analysisTrack->GetMCPID();
      if (part < 0 || analysisTrack->GetSign() == 0.) continue;
      /* check accepted track (no DCA cut) */
      if (!analysisTrack->AcceptTrack(kFALSE)) continue;
      /* check rapidity */
      if (analysisTrack->GetY(AliPID::ParticleMass(part)) - rapidityShift > rapidityMaxCut || 
	  analysisTrack->GetY(AliPID::ParticleMass(part)) - rapidityShift < rapidityMinCut) continue;
      
      /*** ACCEPTED TRACK WITHIN CORRECT RAPIDTY ***/
      
      /* get track info */
      pt = analysisTrack->GetPt();
      dca = analysisTrack->GetImpactParameter(0);
      charge = analysisTrack->GetMCCharge() > 0. ? kPositive : kNegative;
      if (analysisTrack->IsMCPrimary())
	type = kPrimary;
      else if (analysisTrack->IsMCSecondaryWeakDecay())
	type = kWeakDecay;
      else if (analysisTrack->IsMCSecondaryMaterial())
	type = kMaterial;
      else
	continue;

      /* fill histo */
      hDCAopen[type][part][charge]->Fill(cent, pt, dca);
      
      /* check accepted track (with DCA cut) */
      if (!analysisTrack->AcceptTrack(kTRUE)) continue;
      
      /* fill histo */
      hDCAcut[type][part][charge]->Fill(cent, pt, dca);
      
    } /* end of loop over tracks */
  } /* end of loop over events */
  
  /* stop stopwatch */
  timer.Stop();
  timer.Print();
  
  /* output */
  TFile *fileout = TFile::Open(Form("DCAmc.%s", filename), "RECREATE");
  for (Int_t ihisto = 0; ihisto < kNMCHistos; ihisto++) {
    for (Int_t ipart = 0; ipart < AliPID::kSPECIES; ipart++) {
      for (Int_t icharge = 0; icharge < kNCharges; icharge++) {
	hDCAopen[ihisto][ipart][icharge]->Write();
	hDCAcut[ihisto][ipart][icharge]->Write();
      }
    }
  }

  fileout->Close();
  
}

/**************************************************************/

enum EFitParams_t {
  kIntegralCounts,
  kPrimaryCounts,
  kWeakDecayCounts,
  kMaterialCounts,
  kPrimaryIntegral,
  kWeakDecayIntegral,
  kMaterialIntegral,
  kDataCutIntegral,
  kPrimaryCutIntegral,
  kWeakDecayCutIntegral,
  kMaterialCutIntegral,
  kNFitParams
};

/* fit output params name */
const Char_t *fitParamName[kNFitParams] = {
  "IntegralCounts",
  "PrimaryCounts",
  "WeakDecayCounts",
  "MaterialCounts",
  "PrimaryIntegral",
  "WeakDecayIntegral",
  "MaterialIntegral",
  "DataCutIntegral",
  "PrimaryCutIntegral",
  "WeakDecayCutIntegral",
  "MaterialCutIntegral"
};

/* fit output params title */
const Char_t *fitParamTitle[kNFitParams] = {
  "Integral counts;p_{T} (GeV/c);",
  "Primary counts;p_{T} (GeV/c);",
  "Weak-decay counts;p_{T} (GeV/c);",
  "Material counts;p_{T} (GeV/c);",
  "Primary integral;p_{T} (GeV/c);",
  "Weak-decay integral;p_{T} (GeV/c);",
  "Material integral;p_{T} (GeV/c);",
  "Data cut integral;p_{T} (GeV/c);",
  "Primary cut integral;p_{T} (GeV/c);",
  "Weak-decay cut integral;p_{T} (GeV/c);",
  "Material cut integral;p_{T} (GeV/c);"
};

/* fit ranges */
Double_t fitPtMin[AliPID::kSPECIES] = {0.5, 0.5, 0.3, 0.4, 0.5};
Double_t fitPtMax[AliPID::kSPECIES] = {2.0, 2.0, 2.0, 2.0, 3.0};

/* rebin DCA */
Int_t rebindca = 10;

DCAdeltafeed(const Char_t *datafilename, const Char_t *mcfilename)
{
  for (Int_t icharge = 0; icharge < kNCharges; icharge++) {
    DCAdeltafeed(datafilename, mcfilename, 2, icharge, -1);
    DCAdeltafeed(datafilename, mcfilename, 4, icharge, -1);
    for (Int_t icent = 0; icent < NcentralityBins; icent++) {
      DCAdeltafeed(datafilename, mcfilename, 2, icharge, icent);
      DCAdeltafeed(datafilename, mcfilename, 4, icharge, icent);
    }
  }
}

DCAdeltafeed(const Char_t *datafilename, const Char_t *mcfilename, Int_t ipart, Int_t icharge, Int_t icent, Float_t ptMin = -1., Float_t ptMax = -1., Bool_t checkHistoFlag = kFALSE)
{

  printf("****************************************\n");
  printf("RUNNING DCA FIT:\n");
  printf("RAPIDITY-CUT:   %s\n", AliPID::ParticleName(ipart));
  printf("CHARGE:         %s\n", chargeName[icharge]);
  printf("PARTICLE:       %s\n", AliPID::ParticleName(ipart));
  printf("CENTRALITY BIN: %d\n", icent);
  printf("****************************************\n");

  /* open data */
  TFile *datafilein = TFile::Open(datafilename);
  TFile *mcfilein = TFile::Open(mcfilename);

  /* get histos */
  TH3I *hDCAopen = (TH3I *)datafilein->Get(Form("hDCAopen_%s_%s", AliPID::ParticleName(ipart), chargeName[icharge]));
  TH3I *hDCAopen_primary = (TH3I *)mcfilein->Get(Form("hDCAopen_primary_%s_%s", AliPID::ParticleName(ipart), chargeName[icharge]));
  TH3I *hDCAopen_weakdecay = (TH3I *)mcfilein->Get(Form("hDCAopen_weakdecay_%s_%s", AliPID::ParticleName(ipart), chargeName[icharge]));
  TH3I *hDCAopen_material = (TH3I *)mcfilein->Get(Form("hDCAopen_material_%s_%s", AliPID::ParticleName(ipart), chargeName[icharge]));
  TH3I *hDCAcut = (TH3I *)datafilein->Get(Form("hDCAcut_%s_%s", AliPID::ParticleName(ipart), chargeName[icharge]));
  TH3I *hDCAcut_primary = (TH3I *)mcfilein->Get(Form("hDCAcut_primary_%s_%s", AliPID::ParticleName(ipart), chargeName[icharge]));
  TH3I *hDCAcut_weakdecay = (TH3I *)mcfilein->Get(Form("hDCAcut_weakdecay_%s_%s", AliPID::ParticleName(ipart), chargeName[icharge]));
  TH3I *hDCAcut_material = (TH3I *)mcfilein->Get(Form("hDCAcut_material_%s_%s", AliPID::ParticleName(ipart), chargeName[icharge]));

  /* setup centrality range */
  if (icent < 0 || icent >= NcentralityBins) {
    printf("WARNING: undefined centrality -> using 00-90\% range\n");
    hDCAopen->GetXaxis()->SetRange(1, NcentralityBins);
    hDCAopen_primary->GetXaxis()->SetRange(1, NcentralityBins);
    hDCAopen_weakdecay->GetXaxis()->SetRange(1, NcentralityBins);
    hDCAopen_material->GetXaxis()->SetRange(1, NcentralityBins);
    hDCAcut->GetXaxis()->SetRange(1, NcentralityBins);
    hDCAcut_primary->GetXaxis()->SetRange(1, NcentralityBins);
    hDCAcut_weakdecay->GetXaxis()->SetRange(1, NcentralityBins);
    hDCAcut_material->GetXaxis()->SetRange(1, NcentralityBins);
  }
  else {
    printf("***** FITTING CENTRALITY-BIN [%02d, %02d] %% *****\n", centralityBin[icent], centralityBin[icent + 1]);
    hDCAopen->GetXaxis()->SetRange(icent + 1, icent + 1);
#if 0
    hDCAopen_primary->GetXaxis()->SetRange(icent + 1, icent + 1);
    hDCAopen_weakdecay->GetXaxis()->SetRange(icent + 1, icent + 1);
    hDCAopen_material->GetXaxis()->SetRange(icent + 1, icent + 1);
#else
    hDCAopen_primary->GetXaxis()->SetRange(1, NcentralityBins);
    hDCAopen_weakdecay->GetXaxis()->SetRange(1, NcentralityBins);
    hDCAopen_material->GetXaxis()->SetRange(1, NcentralityBins);
#endif
    hDCAcut->GetXaxis()->SetRange(icent + 1, icent + 1);
#if 0
    hDCAcut_primary->GetXaxis()->SetRange(icent + 1, icent + 1);
    hDCAcut_weakdecay->GetXaxis()->SetRange(icent + 1, icent + 1);
    hDCAcut_material->GetXaxis()->SetRange(icent + 1, icent + 1);
#else
    hDCAcut_primary->GetXaxis()->SetRange(1, NcentralityBins);
    hDCAcut_weakdecay->GetXaxis()->SetRange(1, NcentralityBins);
    hDCAcut_material->GetXaxis()->SetRange(1, NcentralityBins);
#endif
  }

  /* setup pt range */
  Bool_t requestedRange = kFALSE;
  if (ptMin > -0.001 && ptMax > -0.001 && ptMax > ptMin) {
    printf("***** FITTING PT-BIN [%f, %f] GeV/c *****\n", ptMin, ptMax);
    requestedRange = kTRUE;
    hDCAopen->GetYaxis()->SetRangeUser(ptMin + 0.001, ptMax - 0.001);
    hDCAopen_primary->GetYaxis()->SetRangeUser(ptMin + 0.001, ptMax - 0.001);
    hDCAopen_weakdecay->GetYaxis()->SetRangeUser(ptMin + 0.001, ptMax - 0.001);
    hDCAopen_material->GetYaxis()->SetRangeUser(ptMin + 0.001, ptMax - 0.001);
    hDCAcut->GetYaxis()->SetRangeUser(ptMin + 0.001, ptMax - 0.001);
    hDCAcut_primary->GetYaxis()->SetRangeUser(ptMin + 0.001, ptMax - 0.001);
    hDCAcut_weakdecay->GetYaxis()->SetRangeUser(ptMin + 0.001, ptMax - 0.001);
    hDCAcut_material->GetYaxis()->SetRangeUser(ptMin + 0.001, ptMax - 0.001);
  }

  /* output */
  Char_t outfilename[1024];
  if (icent < 0 || icent >= NcentralityBins)
    sprintf(outfilename, "DCAdeltafeed_cent0090_%s_%s.root", AliPID::ParticleName(ipart), chargeName[icharge]);
  else {
    sprintf(outfilename, "DCAdeltafeed_cent%02d%02d_%s_%s.root", centralityBin[icent], centralityBin[icent + 1], AliPID::ParticleName(ipart), chargeName[icharge]);
  }
  TFile *fileout = TFile::Open(outfilename, "RECREATE");
  TDirectory *fitDir = fileout->mkdir("FitParams");
  /* canvas */
  TCanvas *canvas = new TCanvas("canvas");
  canvas->SetLogy();
  /* histo */
  TH1D *hFitParamHisto[kNFitParams];
  for (Int_t iparam = 0; iparam < kNFitParams; iparam++)
    hFitParamHisto[iparam] = new TH1D(Form("h%s", fitParamName[iparam]), fitParamTitle[iparam], NptBins, ptBin);


  /* loop over ptBins */
  for (Int_t ipt = 0; ipt < NptBins; ipt++) {
    
    if (!requestedRange) {
      if ((ptBin[ipt] + 0.001) < fitPtMin[ipart] || (ptBin[ipt + 1] - 0.001) > fitPtMax[ipart]) continue;
      printf("***** FITTING PT-BIN [%f, %f] GeV/c *****\n", ptBin[ipt], ptBin[ipt + 1]);
      hDCAopen->GetYaxis()->SetRange(ipt + 1, ipt + 1);
      hDCAopen_primary->GetYaxis()->SetRange(ipt + 1, ipt + 1);
      hDCAopen_weakdecay->GetYaxis()->SetRange(ipt + 1, ipt + 1);
      hDCAopen_material->GetYaxis()->SetRange(ipt + 1, ipt + 1);
      hDCAcut->GetYaxis()->SetRange(ipt + 1, ipt + 1);
      hDCAcut_primary->GetYaxis()->SetRange(ipt + 1, ipt + 1);
      hDCAcut_weakdecay->GetYaxis()->SetRange(ipt + 1, ipt + 1);
      hDCAcut_material->GetYaxis()->SetRange(ipt + 1, ipt + 1);
    }
    
    /* dca projections */
    TH1 *hDCAopen_py = hDCAopen->Project3D("z");
    TH1 *hDCAopen_primary_py = hDCAopen_primary->Project3D("z");
    TH1 *hDCAopen_weakdecay_py = hDCAopen_weakdecay->Project3D("z");
    TH1 *hDCAopen_material_py = hDCAopen_material->Project3D("z");
    TH1 *hDCAcut_py = hDCAcut->Project3D("z");
    TH1 *hDCAcut_primary_py = hDCAcut_primary->Project3D("z");
    TH1 *hDCAcut_weakdecay_py = hDCAcut_weakdecay->Project3D("z");
    TH1 *hDCAcut_material_py = hDCAcut_material->Project3D("z");

    /* rebin */
    hDCAopen_py->Rebin(rebindca);
    hDCAopen_primary_py->Rebin(rebindca);
    hDCAopen_weakdecay_py->Rebin(rebindca);
    hDCAopen_material_py->Rebin(rebindca);
    hDCAcut_py->Rebin(rebindca);
    hDCAcut_primary_py->Rebin(rebindca);
    hDCAcut_weakdecay_py->Rebin(rebindca);
    hDCAcut_material_py->Rebin(rebindca);

    /* check histos if requested */
    if (checkHistoFlag) {
      TCanvas *cCheckHisto = new TCanvas("cCheckHisto");
      cCheckHisto->Divide(2, 4);
      cCheckHisto->cd(1);
      hDCAopen_py->Draw();
      cCheckHisto->cd(2);
      hDCAcut_py->Draw();
      cCheckHisto->cd(3);
      hDCAopen_primary_py->Draw();
      cCheckHisto->cd(4);
      hDCAcut_primary_py->Draw();
      cCheckHisto->cd(5);
      hDCAopen_weakdecay_py->Draw();
      cCheckHisto->cd(6);
      hDCAcut_weakdecay_py->Draw();
      cCheckHisto->cd(7);
      hDCAopen_material_py->Draw();
      cCheckHisto->cd(8);
      hDCAcut_material_py->Draw();
      return;
    }

    Double_t param[kNFitParams];
    Double_t param_err[kNFitParams];

    param[kPrimaryIntegral] = hDCAopen_primary_py->Integral();
    param_err[kPrimaryIntegral] = TMath::Sqrt(hDCAopen_primary_py->Integral());
    param[kWeakDecayIntegral] = hDCAopen_weakdecay_py->Integral();
    param_err[kWeakDecayIntegral] = TMath::Sqrt(hDCAopen_weakdecay_py->Integral());
    param[kMaterialIntegral] = hDCAopen_material_py->Integral();
    param_err[kMaterialIntegral] = TMath::Sqrt(hDCAopen_material_py->Integral());
    
    param[kDataCutIntegral] = hDCAcut_py->Integral();
    param_err[kDataCutIntegral] = TMath::Sqrt(hDCAcut_py->Integral());
    param[kPrimaryCutIntegral] = hDCAcut_primary_py->Integral();
    param_err[kPrimaryCutIntegral] = TMath::Sqrt(hDCAcut_primary_py->Integral());
    param[kWeakDecayCutIntegral] = hDCAcut_weakdecay_py->Integral();
    param_err[kWeakDecayCutIntegral] = TMath::Sqrt(hDCAcut_weakdecay_py->Integral());
    param[kMaterialCutIntegral] = hDCAcut_material_py->Integral();
    param_err[kMaterialCutIntegral] = TMath::Sqrt(hDCAcut_material_py->Integral());

    /* fit */
    DCAfit(hDCAopen_py, hDCAopen_primary_py, hDCAopen_weakdecay_py, hDCAopen_material_py, param, param_err, canvas);

    
    /* check requested pt-range */
    if (requestedRange)
      return;

    /* write canvas */
    fitDir->cd();
    canvas->Write(Form("fitDisplay_ptBin_%3.2f_%3.2f", ptBin[ipt], ptBin[ipt + 1]));
    
    /* set histo */
    for (Int_t iparam = 0; iparam < kNFitParams; iparam++) {
      hFitParamHisto[iparam]->SetBinContent(ipt + 1, param[iparam]);
      hFitParamHisto[iparam]->SetBinError(ipt + 1, param_err[iparam]);
    }

    /* delete */
    delete hDCAopen_py;
    delete hDCAopen_primary_py;
    delete hDCAopen_weakdecay_py;
    delete hDCAopen_material_py;
    delete hDCAcut_py;
    delete hDCAcut_primary_py;
    delete hDCAcut_weakdecay_py;
    delete hDCAcut_material_py;

  }

  /* check requested pt-range */
  if (requestedRange)
    return;

  /*** POST-ANALYSIS ***/

  TDirectory *postDir = fileout->mkdir("PostAnalysis");
 
  /* compute fractions */
  TH1D *hPrimaryFraction = new TH1D(*hFitParamHisto[kPrimaryCounts]);
  hPrimaryFraction->Divide(hFitParamHisto[kPrimaryCounts], hFitParamHisto[kIntegralCounts], 1., 1., "B");
  TH1D *hWeakDecayFraction = new TH1D(*hFitParamHisto[kWeakDecayCounts]);
  hWeakDecayFraction->Divide(hFitParamHisto[kWeakDecayCounts], hFitParamHisto[kIntegralCounts], 1., 1., "B");
  TH1D *hMaterialFraction = new TH1D(*hFitParamHisto[kMaterialCounts]);
  hMaterialFraction->Divide(hFitParamHisto[kMaterialCounts], hFitParamHisto[kIntegralCounts], 1., 1., "B");

  /* compute scale factors */
  TH1D *hPrimaryScale = new TH1D(*hFitParamHisto[kPrimaryCounts]);
  hPrimaryScale->Divide(hFitParamHisto[kPrimaryCounts], hFitParamHisto[kPrimaryIntegral], 1., 1., "B");
  TH1D *hWeakDecayScale = new TH1D(*hFitParamHisto[kWeakDecayCounts]);
  hWeakDecayScale->Divide(hFitParamHisto[kWeakDecayCounts], hFitParamHisto[kWeakDecayIntegral], 1., 1., "B");
  TH1D *hMaterialScale = new TH1D(*hFitParamHisto[kMaterialCounts]);
  hMaterialScale->Divide(hFitParamHisto[kMaterialCounts], hFitParamHisto[kMaterialIntegral], 1., 1., "B");

  /* compute cut integrals */
  TH1D *hPrimaryCutIntegral = new TH1D(*hFitParamHisto[kPrimaryCutIntegral]);
  hPrimaryCutIntegral->Multiply(hPrimaryScale);
  TH1D *hWeakDecayCutIntegral = new TH1D(*hFitParamHisto[kWeakDecayCutIntegral]);
  hWeakDecayCutIntegral->Multiply(hWeakDecayScale);
  TH1D *hMaterialCutIntegral = new TH1D(*hFitParamHisto[kMaterialCutIntegral]);
  hMaterialCutIntegral->Multiply(hMaterialScale);

  /* compute cut fractions */
  TH1D *hPrimaryCutFraction = new TH1D(*hPrimaryCutIntegral);
  hPrimaryCutFraction->Divide(hPrimaryCutIntegral, hFitParamHisto[kDataCutIntegral], 1., 1., "B");
  TH1D *hWeakDecayCutFraction = new TH1D(*hWeakDecayCutIntegral);
  hWeakDecayCutFraction->Divide(hWeakDecayCutIntegral, hFitParamHisto[kDataCutIntegral], 1., 1., "B");
  TH1D *hMaterialCutFraction = new TH1D(*hMaterialCutIntegral);
  hMaterialCutFraction->Divide(hMaterialCutIntegral, hFitParamHisto[kDataCutIntegral], 1., 1., "B");


  /*** OUTPUT ***/

  /* write fir params histos */
  fitDir->cd();
  for (Int_t iparam = 0; iparam < kNFitParams; iparam++)
    hFitParamHisto[iparam]->Write();
  /* write post-analysis histos */
  postDir->cd();
  hPrimaryFraction->Write("hPrimaryFraction");
  hWeakDecayFraction->Write("hWeakDecayFraction");
  hMaterialFraction->Write("hMaterialFraction");
  hPrimaryCutFraction->Write("hPrimaryCutFraction");
  hWeakDecayCutFraction->Write("hWeakDecayCutFraction");
  hMaterialCutFraction->Write("hMaterialCutFraction");

  /* cleanup */
  delete hPrimaryFraction;
  delete hWeakDecayFraction;
  delete hMaterialFraction;
  delete hPrimaryScale;
  delete hWeakDecayScale;
  delete hMaterialScale;
  delete hPrimaryCutIntegral;
  delete hWeakDecayCutIntegral;
  delete hMaterialCutIntegral;
  delete hPrimaryCutFraction;
  delete hWeakDecayCutFraction;
  delete hMaterialCutFraction;
  delete canvas;
  for (Int_t iparam = 0; iparam < kNFitParams; iparam++)
    delete hFitParamHisto[iparam];

  /* close file */
  fileout->Close();


}

/**************************************************************/

//___________________________________________________________________________________

Float_t 
TOFpid_histomin(TH1 *h)
{

  for (Int_t ibin = 0; ibin < h->GetNbinsX(); ibin++)
    if (h->GetBinContent(ibin + 1) > 0.)
      return h->GetXaxis()->GetBinCenter(ibin + 1);
  return kMaxInt;
}

//___________________________________________________________________________________

Float_t 
TOFpid_histomax(TH1 *h)
{

  for (Int_t ibin = h->GetNbinsX(); ibin > 0; ibin--)
    if (h->GetBinContent(ibin) > 0.)
      return h->GetXaxis()->GetBinCenter(ibin);
  return -kMaxInt;
}

//___________________________________________________________________________________

TOFpid_checkneg(TH1 *h)
{

  for (Int_t ibin = 0; ibin < h->GetNbinsX(); ibin++)
    if (h->GetBinContent(ibin + 1) <= 0.) {
      h->SetBinContent(ibin + 1, 1.e-300);
      //      h->SetBinError(ibin + 1, 0.1);
    }
}


Double_t
DCAfit(TH1 *hData, TH1 *hPrimary, TH1 *hWeakDecay, TH1 *hMaterial, Double_t *param = NULL, Double_t *param_err = NULL, TCanvas *canvas = NULL)
{

  /** ROOFIT ***/
  gSystem->Load("libRooFit");
  using namespace RooFit;

  /*** DEFINE FIT RANGE ***/

  printf("***** FIT RANGE DEFINITION *****\n");

  /* check material histogram to define min/max fit range */
  Double_t rangeMin = TMath::Max(dcaMin, TOFpid_histomin(hMaterial));
  Double_t rangeMax = TMath::Min(dcaMax, TOFpid_histomax(hMaterial));
  /* fix zeroes */
  TOFpid_checkneg(hMaterial);

  /* define range */
  RooRealVar x("x", "DCA_{xy}", 0., -5., 5., "");
  printf("FIT RANGE DEFINED: %f -> %f\n", dcaMin, dcaMax);
  printf("********************************\n");

  /*** DEFINE HISTOGRAM DATA ***/
  
  /* define data to fit and background from input histogram */
  RooDataHist hdata("hdata", "hdata", x, hData);
  RooDataHist hprimary("hprimary", "hprimary", x, hPrimary);
  RooDataHist hweakdecay("hweakdecay", "hweakdecay", x, hWeakDecay);
  RooDataHist hmaterial("hmaterial", "hmaterial", x, hMaterial);

  /*** DEFINE SHAPES ***/

  RooHistPdf primary("primary", "primary", x, hprimary);
  RooHistPdf weakdecay("weakdecay", "weakdecay", x, hweakdecay);
  RooHistPdf material("material", "material", x, hmaterial);

  /*** DEFINE MODEL ***/

  Double_t integral = hdata.sumEntries();
  RooRealVar nprimary("nprimary", "nprimary", 0.80 * integral, 0., integral);
  RooRealVar nweakdecay("nweakdecay", "nweakdecay", 0.1 * integral, 0., integral);
  RooRealVar nmaterial("nmaterial", "nmaterial", 0.1 * integral, 0., integral);

  RooAddPdf model("model", "model p.d.f.", RooArgList(primary, weakdecay, material), RooArgList(nprimary, nweakdecay, nmaterial));

  /*** FIT ***/

  if (canvas) canvas->cd();
  model.fitTo(hdata, Extended(kTRUE), SumW2Error(kFALSE));

  /*** DRAW ***/

  RooPlot *xframe = x.frame();
  hdata.plotOn(xframe, XErrorSize(0), DrawOption("PZ"));
  model.plotOn(xframe, LineWidth(2), Precision(1.e-4));
  model.plotOn(xframe, Components(primary), LineWidth(2), LineColor(kRed), Precision(1.e-4));
  model.plotOn(xframe, Components(weakdecay), LineWidth(2), LineStyle(kDashed), LineColor(kCyan+1));
  model.plotOn(xframe, Components(material), LineWidth(2), LineStyle(kDashed), LineColor(kGreen+1));
  xframe->SetMinimum(0.1);
  xframe->Draw();
  if (canvas) canvas->Update();

  printf("*****************************\n");
  printf("***** FRACTIONS *****\n");
  printf("primary     = %f +- %f\n", nprimary.getVal(), nprimary.getError());
  printf("weak-decay  = %f +- %f\n", nweakdecay.getVal(), nweakdecay.getError());
  printf("material    = %f +- %f\n", nmaterial.getVal(), nmaterial.getError());
  printf("******************\n");

  /*** OUTPUT FIT PARAMS ***/
  
  param[kIntegralCounts] = integral;
  param_err[kIntegralCounts] = sqrt(integral);
  param[kPrimaryCounts] = nprimary.getVal();
  param_err[kPrimaryCounts] = nprimary.getError();
  param[kWeakDecayCounts] = nweakdecay.getVal();
  param_err[kWeakDecayCounts] = nweakdecay.getError();
  param[kMaterialCounts] = nmaterial.getVal();
  param_err[kMaterialCounts] = nmaterial.getError();

  return;

}

enum EFitFunc_t {
  kExpo,
  kInverseExpo,
  kPowerLaw,
  kInversePowerLaw,
  kExpoPowerLaw
};

DCAdeltafeed_param()
{
#if 0
  DCAdeltafeed_param(2, 0, "WeakDecayCutFraction", kExpo);
  DCAdeltafeed_param(2, 1, "WeakDecayCutFraction", kExpo);
  DCAdeltafeed_param(4, 0, "WeakDecayCutFraction", kExpo);
  DCAdeltafeed_param(4, 1, "WeakDecayCutFraction", kExpo);
  DCAdeltafeed_param(2, 0, "MaterialCutFraction", kPowerLaw);
  DCAdeltafeed_param(2, 1, "MaterialCutFraction", kPowerLaw);
  DCAdeltafeed_param(4, 0, "MaterialCutFraction", kPowerLaw);
  DCAdeltafeed_param(4, 1, "MaterialCutFraction", kPowerLaw);
#endif
  DCAdeltafeed_param_bothcharges(2, 0, "PrimaryCutFraction", kInverseExpo);
  DCAdeltafeed_param_bothcharges(2, 1, "PrimaryCutFraction", kInverseExpo);
  DCAdeltafeed_param_bothcharges(4, 0, "PrimaryCutFraction", kInverseExpo);
  DCAdeltafeed_param_bothcharges(4, 1, "PrimaryCutFraction", kInverseExpo);
}

DCAdeltafeed_param_bothcharges(Int_t ipart, Int_t icharge, const Char_t *name, Int_t fitFunc)
{

  TVirtualFitter::SetMaxIterations(1000000);
  
  /* load HistoUtils */
  gROOT->LoadMacro("HistoUtils.C");

  Char_t outfilename[1024];
  TH1D *hDeltaFeed_mb[kNCharges];
  TH1D *hDeltaFeed_cent[kNCharges][NcentralityBins];
  for (Int_t iicharge = 0; iicharge < kNCharges; iicharge++) {

    /* get minimum-bias results */
    sprintf(outfilename, "DCAdeltafeed_cent0090_%s_%s.root", AliPID::ParticleName(ipart), chargeName[iicharge]);
    TFile *filein = TFile::Open(outfilename);
    hDeltaFeed_mb[iicharge] = (TH1D *)filein->Get(Form("PostAnalysis/h%s", name));
    if (!hDeltaFeed_mb[iicharge]) {
      printf("cannot find PostAnalysis/h%s in %s\n", name, outfilename);
      return;
    }

    /* get centrality-binned results */
    for (Int_t icent = 0; icent < NcentralityBins; icent++) {
      sprintf(outfilename, "DCAdeltafeed_cent%02d%02d_%s_%s.root", centralityBin[icent], centralityBin[icent + 1], AliPID::ParticleName(ipart), chargeName[iicharge]);
      filein = TFile::Open(outfilename);
      if (!filein || !filein->IsOpen()) continue;
      hDeltaFeed_cent[iicharge][icent] = (TH1D *)filein->Get(Form("PostAnalysis/h%s", name));
      if (!hDeltaFeed_cent[iicharge][icent]) {
	printf("cannot find PostAnalysis/h%s in %s\n", name, outfilename);
	return;
      }
    }
  }

  /* define delta feed-down function */
  switch (fitFunc) {
  case kExpo:
    printf("expo function selected\n");
    TF1 *fDeltaFeed = new TF1("fDeltaFeed_expo", "[0] * ([1] + [2] * TMath::Exp([3] * x))", 0.5, 5.);
    fDeltaFeed->SetParameter(1, 0.01);
    fDeltaFeed->SetParLimits(1, 0., 0.1);
    fDeltaFeed->SetParameter(2, 0.1);
    fDeltaFeed->SetParameter(3, -1.);
    break;
  case kInverseExpo:
    printf("inverse-expo function selected\n");
    TF1 *fDeltaFeed = new TF1("fDeltaFeed_expo", "[0] * ([1] + [2] * TMath::Exp([3] * x))", 0.5, 5.);
    fDeltaFeed->SetParameter(1, 1.);
    fDeltaFeed->SetParLimits(1, 0.9, 1.0);
    fDeltaFeed->SetParameter(2, -0.1);
    fDeltaFeed->SetParLimits(2, -1., 0.);
    fDeltaFeed->SetParameter(3, -1.);
    break;
  case kPowerLaw:
    printf("powerlaw function selected\n");
    TF1 *fDeltaFeed = new TF1("fDeltaFeed_powerlaw", "[0] * ([1] + [2] * TMath::Power(x, [3]))", 0.5, 5.);
    fDeltaFeed->SetParameter(1, 0.01);
    fDeltaFeed->SetParLimits(1, 0., 0.1);
    fDeltaFeed->SetParameter(2, 0.1);
    fDeltaFeed->SetParameter(3, -1.);
    break;
  case kInversePowerLaw:
    printf("inverse-powerlaw function selected\n");
    TF1 *fDeltaFeed = new TF1("fDeltaFeed_powerlaw", "[0] * ([1] + [2] * TMath::Power(x, [3]) + [4] * x)", 0.5, 5.);
    fDeltaFeed->SetParameter(1, 1.);
    fDeltaFeed->SetParLimits(1, 0.9, 1.);
    fDeltaFeed->SetParameter(2, -0.1);
    fDeltaFeed->SetParameter(3, -1.);
    fDeltaFeed->SetParameter(4, 0.);
    fDeltaFeed->SetParLimits(4, 0., 1.)
    break;
  case kExpoPowerLaw:
    printf("expo+powerlaw function selected\n");
    TF1 *fDeltaFeed = new TF1("fDeltaFeed_expopowerlaw", "[0] * ([1] + [2] * TMath::Exp([3] * x) + [4] * TMath::Exp([5] * x))", 0.5, 5.);

    fDeltaFeed->SetParameter(1, 0.95);
    fDeltaFeed->SetParLimits(1, 0.9, 1.);
    fDeltaFeed->SetParameter(2, -0.1);
    fDeltaFeed->SetParLimits(2, -1000., 0.);
    fDeltaFeed->SetParameter(3, -1.);
    fDeltaFeed->SetParameter(4, -100.);
    fDeltaFeed->SetParLimits(4, -100., 0.);
    fDeltaFeed->SetParameter(5, -20.);
    fDeltaFeed->SetParLimits(5, -100., 10.);
    break;
  default:
    printf("fit function not defined\n");
    return;
    break;
  }
  fDeltaFeed->FixParameter(0, 1.);

  /* output */
  TFile *fileout = TFile::Open(Form("DCAdeltafeed_param_%s_%s_%s.root", name, AliPID::ParticleName(ipart), chargeName[icharge]), "RECREATE");

  /* extra-material function */
  TF1 *fExtraMaterial = new TF1("fExtraMaterial", "1. + [0] * TMath::Exp([1] * x)", 0., 5.);
  fExtraMaterial->SetParameter(0, 0.1);
  fExtraMaterial->SetParameter(1, -0.5);

  /* loop over centrality bins */
  for (Int_t icent = -1; icent < NcentralityBins; icent++) {

    printf(" icent = %d\n", icent);
    
    /* fit material from proton-antiproton ratio and remove it */
    if (ipart == AliPID::kProton) {
      printf("fitting extra-material for positive protons\n");
      if (icent == -1) {
	TH1D *hr = new TH1D(*hDeltaFeed_mb[kPositive]);
	hr->Divide(hDeltaFeed_mb[kNegative]);
	hr->Fit(fExtraMaterial, "R", "", fitPtMin[ipart], fitPtMax[ipart]);
	hDeltaFeed_mb[kPositive]->Divide(fExtraMaterial);
      }
      else {
	TH1D *hr = new TH1D(*hDeltaFeed_cent[kPositive][icent]);
	hr->Divide(hDeltaFeed_cent[kNegative][icent]);
	hr->Fit(fExtraMaterial, "R", "", fitPtMin[ipart], fitPtMax[ipart]);
	hDeltaFeed_cent[kPositive][icent]->Divide(fExtraMaterial);
      }
    }
    
    /* build graph with both charges */
    TGraphErrors *gDeltaFeed = new TGraphErrors();
    Int_t npoints = 0;
    Double_t pt, pte, val, vale;
    for (Int_t iicharge = 0; iicharge < kNCharges; iicharge++) {
      for (Int_t ipt = 0; ipt < NptBins; ipt++) {
	if (icent == -1) {
	  if (hDeltaFeed_mb[iicharge]->GetBinError(ipt + 1) == 0.)
	    continue;
	  pt = hDeltaFeed_mb[iicharge]->GetBinCenter(ipt + 1);
	  pte = 0.5 * hDeltaFeed_mb[iicharge]->GetBinWidth(ipt + 1);
	  val = hDeltaFeed_mb[iicharge]->GetBinContent(ipt + 1);
	  vale = hDeltaFeed_mb[iicharge]->GetBinError(ipt + 1);
	  gDeltaFeed->SetPoint(npoints, pt, val);
	  gDeltaFeed->SetPointError(npoints, pte, vale);
	  npoints++;
	}
	else {
	  if (hDeltaFeed_cent[iicharge][icent]->GetBinError(ipt + 1) == 0.)
	    continue;
	  pt = hDeltaFeed_cent[iicharge][icent]->GetBinCenter(ipt + 1);
	  pte = 0.5 * hDeltaFeed_cent[iicharge][icent]->GetBinWidth(ipt + 1);
	  val = hDeltaFeed_cent[iicharge][icent]->GetBinContent(ipt + 1);
	  vale = hDeltaFeed_cent[iicharge][icent]->GetBinError(ipt + 1);
	  gDeltaFeed->SetPoint(npoints, pt, val);
	  gDeltaFeed->SetPointError(npoints, pte, vale);
	  npoints++;
	}
      }
    }

    /* fit graph */
    Int_t fitres = -1;
    fitres = gDeltaFeed->Fit(fDeltaFeed, "R", "", 0.5, 2.0);
    if (fitres != 0) {
      fDeltaFeed->SetParLimits(1, 0.9, 1.0);
      fDeltaFeed->SetParameter(2, -0.1);
      fDeltaFeed->SetParLimits(2, -1., 0.);
      fDeltaFeed->SetParameter(3, -1.);
    }
    fitres = -1;
    while(fitres != 0)
      fitres = gDeltaFeed->Fit(fDeltaFeed, "R", "", fitPtMin[ipart], fitPtMax[ipart]);
    
    gDeltaFeed->Draw("ap*");
    fDeltaFeed->Draw("same");
    gPad->Update();
    
    printf("done part = %d, charge = %d, cent = %d\n", ipart, icharge, icent);

    /* build fit profile */
    TProfile *pDeltaFeed = new TProfile("pDeltaFeed", "", NptBins, ptBin);
    HistoUtils_Function2Profile(fDeltaFeed, pDeltaFeed);

    /* put material back */
    if (ipart == AliPID::kProton && icharge == kPositive) {
      if (icent == -1) {
	hDeltaFeed_mb[kPositive]->Multiply(fExtraMaterial);
	pDeltaFeed->Multiply(fExtraMaterial);
      }
      else {
	hDeltaFeed_cent[kPositive][icent]->Multiply(fExtraMaterial);
	pDeltaFeed->Multiply(fExtraMaterial);
      }
    }
    
    /* write */
    fileout->cd();
    if (icent == -1) {
      hDeltaFeed_mb[icharge]->Write(Form("hDeltaFeed_MB"));
      fDeltaFeed->Write(Form("fDeltaFeed_MB"));
      pDeltaFeed->Write(Form("pDeltaFeed_MB"));
      fExtraMaterial->Write(Form("fExtraMaterial_MB"));
    }
    else {
      hDeltaFeed_cent[icharge][icent]->Write(Form("hDeltaFeed_cent%d", icent));
      fDeltaFeed->Write(Form("fDeltaFeed_cent%d", icent));
      pDeltaFeed->Write(Form("pDeltaFeed_cent%d", icent));
      fExtraMaterial->Write(Form("fExtraMaterial_cent%d", icent));
    }
  }
  
  fileout->Close();
}

DCAdeltafeed_param(Int_t ipart, Int_t icharge, const Char_t *name, Int_t fitFunc)
{

  TVirtualFitter::SetMaxIterations(1000000);

  /* load HistoUtils */
  gROOT->LoadMacro("HistoUtils.C");
  
  /* get minimum-bias results */
  Char_t outfilename[1024];
  sprintf(outfilename, "DCAdeltafeed_cent0090_%s_%s.root", AliPID::ParticleName(ipart), chargeName[icharge]);
  TFile *filein = TFile::Open(outfilename);
  TH1D *hDeltaFeed_mb = (TH1D *)filein->Get(Form("PostAnalysis/h%s", name));
  if (!hDeltaFeed_mb) {
    printf("cannot find PostAnalysis/h%s in %s\n", name, outfilename);
    return;
  }

  /* get centrality-binned results */
  TH1D *hDeltaFeed_cent[NcentralityBins];
  for (Int_t icent = 0; icent < NcentralityBins; icent++) {
    sprintf(outfilename, "DCAdeltafeed_cent%02d%02d_%s_%s.root", centralityBin[icent], centralityBin[icent + 1], AliPID::ParticleName(ipart), chargeName[icharge]);
    filein = TFile::Open(outfilename);
    if (!filein || !filein->IsOpen()) continue;
    hDeltaFeed_cent[icent] = (TH1D *)filein->Get(Form("PostAnalysis/h%s", name));
    if (!hDeltaFeed_cent[icent]) {
      printf("cannot find PostAnalysis/h%s in %s\n", name, outfilename);
      return;
    }
  }
 
  /* define delta feed-down function */
  switch (fitFunc) {
  case kExpo:
    printf("expo function selected\n");
    TF1 *fDeltaFeed = new TF1("fDeltaFeed_expo", "[0] * ([1] + [2] * TMath::Exp([3] * x))", 0.5, 5.);
    fDeltaFeed->SetParameter(1, 0.01);
    fDeltaFeed->SetParLimits(1, 0., 0.1);
    fDeltaFeed->SetParameter(2, 0.1);
    fDeltaFeed->SetParameter(3, -1.);
    break;
  case kInverseExpo:
    printf("inverse-expo function selected\n");
    TF1 *fDeltaFeed = new TF1("fDeltaFeed_expo", "[0] * ([1] + [2] * TMath::Exp([3] * x))", 0.5, 5.);
    fDeltaFeed->SetParameter(1, 1.);
    fDeltaFeed->SetParLimits(1, 0.9, 1.0);
    fDeltaFeed->SetParameter(2, -0.1);
    fDeltaFeed->SetParameter(3, -1.);
    break;
  case kPowerLaw:
    printf("powerlaw function selected\n");
    TF1 *fDeltaFeed = new TF1("fDeltaFeed_powerlaw", "[0] * ([1] + [2] * TMath::Power(x, [3]))", 0.5, 5.);
    fDeltaFeed->SetParameter(1, 0.01);
    fDeltaFeed->SetParLimits(1, 0., 0.1);
    fDeltaFeed->SetParameter(2, 0.1);
    fDeltaFeed->SetParameter(3, -1.);
    break;
  case kInversePowerLaw:
    printf("inverse-powerlaw function selected\n");
    TF1 *fDeltaFeed = new TF1("fDeltaFeed_powerlaw", "[0] * ([1] + [2] * TMath::Power(x, [3]) + [4] * x)", 0.5, 5.);
    fDeltaFeed->SetParameter(1, 1.);
    fDeltaFeed->SetParLimits(1, 0.9, 1.);
    fDeltaFeed->SetParameter(2, -0.1);
    fDeltaFeed->SetParameter(3, -1.);
    fDeltaFeed->SetParameter(4, 0.);
    fDeltaFeed->SetParLimits(4, 0., 1.)
    break;
  case kExpoPowerLaw:
    printf("expo+powerlaw function selected\n");
    //    TF1 *fDeltaFeed = new TF1("fDeltaFeed_expopowerlaw", "[0] * ([1] + [2] * TMath::Exp([3] * x) + [4] * TMath::Exp([5] * x))", 0.5, 5.);
    TF1 *fDeltaFeed = new TF1("fDeltaFeed_expopowerlaw", "[0] * ([1] + [2] * TMath::Exp([3] * x) * TMath::Exp([5] / x))", 0.5, 5.);

    fDeltaFeed->SetParameter(1, 0.95);
    fDeltaFeed->SetParLimits(1, 0.9, 1.);
    fDeltaFeed->SetParameter(2, -0.1);
    fDeltaFeed->SetParLimits(2, -1000., 0.);
    fDeltaFeed->SetParameter(3, -1.);
    fDeltaFeed->SetParameter(4, -100.);
    fDeltaFeed->SetParLimits(4, -100., 0.);
    fDeltaFeed->SetParameter(5, -20.);
    fDeltaFeed->SetParLimits(5, -100., 10.);
    break;
  default:
    printf("fit function not defined\n");
    return;
    break;
  }
  fDeltaFeed->FixParameter(0, 1.);

  /* output */
  TFile *fileout = TFile::Open(Form("DCAdeltafeed_param_%s_%s_%s.root", name, AliPID::ParticleName(ipart), chargeName[icharge]), "RECREATE");

  /* fit minimum-bias */
  TCanvas *cMinimumBias = new TCanvas("cMinimumBias");
  if (fitFunc == kExpoPowerLaw) {
    fDeltaFeed->FixParameter(4, 0.);
    hDeltaFeed_mb->Fit(fDeltaFeed, "IMRE", "", 1.0, 3.0);
    fDeltaFeed->FixParameter(1, fDeltaFeed->GetParameter(1));
    fDeltaFeed->FixParameter(2, fDeltaFeed->GetParameter(2));
    fDeltaFeed->FixParameter(3, fDeltaFeed->GetParameter(3));
    fDeltaFeed->ReleaseParameter(4);
    hDeltaFeed_mb->Fit(fDeltaFeed, "IMRE", "", 0.5, 3.0);
  }
  else {
    hDeltaFeed_mb->Fit(fDeltaFeed, "IMRE", "", 0.5, 3.0);
  }
  cMinimumBias->SetLogy();

  /* build fit profile */
  TProfile *pDeltaFeed = new TProfile("pDeltaFeed", "", NptBins, ptBin);
  HistoUtils_Function2Profile(fDeltaFeed, pDeltaFeed);

  /* save MB params */
  Double_t parMB[100];
  for (Int_t ipar = 0; ipar < fDeltaFeed->GetNpar(); ipar++)
    parMB[ipar] = fDeltaFeed->GetParameter(ipar);
  
  /* write */
  fileout->cd();
  hDeltaFeed_mb->Write("hDeltaFeed_mb");
  fDeltaFeed->Write("fDeltaFeed_mb");
  pDeltaFeed->Write("pDeltaFeed_mb");

  /* fix pt-depencence and release scale factor
     to fit centrality bins */
  TCanvas *cCentralityDependence = new TCanvas("cCentralityDependence");
  TH1D *hCentDep = new TH1D("hCentDep", "", NcentralityBins, centralityBin);
  //fDeltaFeed->ReleaseParameter(0);
  //  for (Int_t ipar = 1; ipar < fDeltaFeed->GetNpar(); ipar++)
  //    fDeltaFeed->FixParameter(ipar, fDeltaFeed->GetParameter(ipar));
  //fDeltaFeed->FixParameter(1, fDeltaFeed->GetParameter(1));
  TProfile *pDeltaFeed_cent[NcentralityBins]; = new TProfile("pDeltaFeed", "", NptBins, ptBin);
  for (Int_t icent = 0; icent < NcentralityBins; icent++) {
    if (!hDeltaFeed_cent[icent]) continue;

    /* restore MB parameters */
    for (Int_t ipar = 0; ipar < fDeltaFeed->GetNpar(); ipar++)
      fDeltaFeed->SetParameter(ipar, parMB[ipar]);

    if (fitFunc == kExpoPowerLaw) {
      fDeltaFeed->FixParameter(4, 0.);
      hDeltaFeed_mb->Fit(fDeltaFeed, "IMRE", "", 1.0, 3.0);
      fDeltaFeed->FixParameter(1, fDeltaFeed->GetParameter(1));
      fDeltaFeed->FixParameter(2, fDeltaFeed->GetParameter(2));
      fDeltaFeed->FixParameter(3, fDeltaFeed->GetParameter(3));
      fDeltaFeed->ReleaseParameter(4);
      hDeltaFeed_cent[icent]->Fit(fDeltaFeed, "IMRE", "", 0.5, 3.0);
    }
    else {
      hDeltaFeed_cent[icent]->Fit(fDeltaFeed, "IMRE", "", 0.5, 3.0);
    }

    pDeltaFeed_cent[icent] = new TProfile(Form("pDeltaFeed_cent%d", icent), "", NptBins, ptBin);
    HistoUtils_Function2Profile(fDeltaFeed, pDeltaFeed_cent[icent]);
    hCentDep->SetBinContent(icent + 1, fDeltaFeed->GetParameter(0.));
    hCentDep->SetBinError(icent + 1, fDeltaFeed->GetParError(0.));

    /* write */
    fileout->cd();
    hDeltaFeed_cent[icent]->Write(Form("hDeltaFeed_cent%d", icent));
    fDeltaFeed->Write(Form("fDeltaFeed_cent%d", icent));
    pDeltaFeed_cent[icent]->Write(Form("pDeltaFeed_cent%d", icent));
    
  }

  /* fit centrality dependence */
  TF1 *fCentDep = (TF1 *)gROOT->GetFunction("pol3");
  //  hCentDep->Fit(fCentDep);
  
  /* build fit profile */
  TProfile *pCentDep = new TProfile("pCentDep", "", NcentralityBins, centralityBin);
  HistoUtils_Function2Profile(fCentDep, pCentDep);
  
  /* write */
  fileout->cd();
  hCentDep->Write("hCentDep");
  fCentDep->Write("fCentDep");
  pCentDep->Write("pCentDep");
  fileout->Close();

}

DCA_primaryFraction(const Char_t *destdir)
{

  Int_t marker[2] = {20, 21};
  Int_t color[AliPID::kSPECIES] = {1, 1, 4, 8, 2};
  Char_t *partLatex[AliPID::kSPECIES][2] = {
    "", "", "", "", "#pi^{+}", "#pi^{-}", "K^{+}", "K^{-}", "p", "#bar{p}"
  };

  TFile *fileout = TFile::Open("TOF_primaryFraction.root", "RECREATE");

  TProfile *pFrac;
  TH1D *hFrac = new TH1D("hFrac", "", NptBins, ptBin);
  Char_t title[1024];
  for (Int_t ipart = 2; ipart < AliPID::kSPECIES; ipart++) {
    if (ipart == 3) continue;
    for (Int_t icharge = 0; icharge < kNCharges; icharge++) {
      TFile *filein = TFile::Open(Form("%s/DCAdeltafeed_param_PrimaryCutFraction_%s_%s.root", destdir, AliPID::ParticleName(ipart), chargeName[icharge]));
      for (Int_t icent = -1; icent < NcentralityBins; icent++) {
	if (icent == -1)
	  pFrac = (TProfile *)filein->Get(Form("pDeltaFeed_MB"));
	else
	  pFrac = (TProfile *)filein->Get(Form("pDeltaFeed_cent%d", icent));
	/* copy profile in TH1D */
	for (Int_t ipt = 0; ipt < NptBins; ipt++) {
	  hFrac->SetBinContent(ipt + 1, pFrac->GetBinContent(ipt + 1));
	  hFrac->SetBinError(ipt + 1, pFrac->GetBinError(ipt + 1));
	}
	if (icent == -1)
	  sprintf(title, "%s (MB);p_{T} (GeV/c);fraction of primary particle;", partLatex[ipart][icharge]);
	else
	  sprintf(title, "%s (%d-%d%%);p_{T} (GeV/c);fraction of primary particle;", partLatex[ipart][icharge], (Int_t)centralityBin[icent], (Int_t)centralityBin[icent + 1]);
	hFrac->SetMarkerStyle(marker[icharge]);
	hFrac->SetMarkerColor(color[ipart]);
	hFrac->SetTitle(title);
	if (icent == -1)
	  hFrac->SetName(Form("hPrimaryFrac_MB_%s_%s", AliPID::ParticleName(ipart), chargeName[icharge]));
	else
	  hFrac->SetName(Form("hPrimaryFrac_cent%d_%s_%s", icent, AliPID::ParticleName(ipart), chargeName[icharge]));
	fileout->cd();
	hFrac->Write();
      }
    }
  }

  fileout->Close();

}
 DCA.C:1
 DCA.C:2
 DCA.C:3
 DCA.C:4
 DCA.C:5
 DCA.C:6
 DCA.C:7
 DCA.C:8
 DCA.C:9
 DCA.C:10
 DCA.C:11
 DCA.C:12
 DCA.C:13
 DCA.C:14
 DCA.C:15
 DCA.C:16
 DCA.C:17
 DCA.C:18
 DCA.C:19
 DCA.C:20
 DCA.C:21
 DCA.C:22
 DCA.C:23
 DCA.C:24
 DCA.C:25
 DCA.C:26
 DCA.C:27
 DCA.C:28
 DCA.C:29
 DCA.C:30
 DCA.C:31
 DCA.C:32
 DCA.C:33
 DCA.C:34
 DCA.C:35
 DCA.C:36
 DCA.C:37
 DCA.C:38
 DCA.C:39
 DCA.C:40
 DCA.C:41
 DCA.C:42
 DCA.C:43
 DCA.C:44
 DCA.C:45
 DCA.C:46
 DCA.C:47
 DCA.C:48
 DCA.C:49
 DCA.C:50
 DCA.C:51
 DCA.C:52
 DCA.C:53
 DCA.C:54
 DCA.C:55
 DCA.C:56
 DCA.C:57
 DCA.C:58
 DCA.C:59
 DCA.C:60
 DCA.C:61
 DCA.C:62
 DCA.C:63
 DCA.C:64
 DCA.C:65
 DCA.C:66
 DCA.C:67
 DCA.C:68
 DCA.C:69
 DCA.C:70
 DCA.C:71
 DCA.C:72
 DCA.C:73
 DCA.C:74
 DCA.C:75
 DCA.C:76
 DCA.C:77
 DCA.C:78
 DCA.C:79
 DCA.C:80
 DCA.C:81
 DCA.C:82
 DCA.C:83
 DCA.C:84
 DCA.C:85
 DCA.C:86
 DCA.C:87
 DCA.C:88
 DCA.C:89
 DCA.C:90
 DCA.C:91
 DCA.C:92
 DCA.C:93
 DCA.C:94
 DCA.C:95
 DCA.C:96
 DCA.C:97
 DCA.C:98
 DCA.C:99
 DCA.C:100
 DCA.C:101
 DCA.C:102
 DCA.C:103
 DCA.C:104
 DCA.C:105
 DCA.C:106
 DCA.C:107
 DCA.C:108
 DCA.C:109
 DCA.C:110
 DCA.C:111
 DCA.C:112
 DCA.C:113
 DCA.C:114
 DCA.C:115
 DCA.C:116
 DCA.C:117
 DCA.C:118
 DCA.C:119
 DCA.C:120
 DCA.C:121
 DCA.C:122
 DCA.C:123
 DCA.C:124
 DCA.C:125
 DCA.C:126
 DCA.C:127
 DCA.C:128
 DCA.C:129
 DCA.C:130
 DCA.C:131
 DCA.C:132
 DCA.C:133
 DCA.C:134
 DCA.C:135
 DCA.C:136
 DCA.C:137
 DCA.C:138
 DCA.C:139
 DCA.C:140
 DCA.C:141
 DCA.C:142
 DCA.C:143
 DCA.C:144
 DCA.C:145
 DCA.C:146
 DCA.C:147
 DCA.C:148
 DCA.C:149
 DCA.C:150
 DCA.C:151
 DCA.C:152
 DCA.C:153
 DCA.C:154
 DCA.C:155
 DCA.C:156
 DCA.C:157
 DCA.C:158
 DCA.C:159
 DCA.C:160
 DCA.C:161
 DCA.C:162
 DCA.C:163
 DCA.C:164
 DCA.C:165
 DCA.C:166
 DCA.C:167
 DCA.C:168
 DCA.C:169
 DCA.C:170
 DCA.C:171
 DCA.C:172
 DCA.C:173
 DCA.C:174
 DCA.C:175
 DCA.C:176
 DCA.C:177
 DCA.C:178
 DCA.C:179
 DCA.C:180
 DCA.C:181
 DCA.C:182
 DCA.C:183
 DCA.C:184
 DCA.C:185
 DCA.C:186
 DCA.C:187
 DCA.C:188
 DCA.C:189
 DCA.C:190
 DCA.C:191
 DCA.C:192
 DCA.C:193
 DCA.C:194
 DCA.C:195
 DCA.C:196
 DCA.C:197
 DCA.C:198
 DCA.C:199
 DCA.C:200
 DCA.C:201
 DCA.C:202
 DCA.C:203
 DCA.C:204
 DCA.C:205
 DCA.C:206
 DCA.C:207
 DCA.C:208
 DCA.C:209
 DCA.C:210
 DCA.C:211
 DCA.C:212
 DCA.C:213
 DCA.C:214
 DCA.C:215
 DCA.C:216
 DCA.C:217
 DCA.C:218
 DCA.C:219
 DCA.C:220
 DCA.C:221
 DCA.C:222
 DCA.C:223
 DCA.C:224
 DCA.C:225
 DCA.C:226
 DCA.C:227
 DCA.C:228
 DCA.C:229
 DCA.C:230
 DCA.C:231
 DCA.C:232
 DCA.C:233
 DCA.C:234
 DCA.C:235
 DCA.C:236
 DCA.C:237
 DCA.C:238
 DCA.C:239
 DCA.C:240
 DCA.C:241
 DCA.C:242
 DCA.C:243
 DCA.C:244
 DCA.C:245
 DCA.C:246
 DCA.C:247
 DCA.C:248
 DCA.C:249
 DCA.C:250
 DCA.C:251
 DCA.C:252
 DCA.C:253
 DCA.C:254
 DCA.C:255
 DCA.C:256
 DCA.C:257
 DCA.C:258
 DCA.C:259
 DCA.C:260
 DCA.C:261
 DCA.C:262
 DCA.C:263
 DCA.C:264
 DCA.C:265
 DCA.C:266
 DCA.C:267
 DCA.C:268
 DCA.C:269
 DCA.C:270
 DCA.C:271
 DCA.C:272
 DCA.C:273
 DCA.C:274
 DCA.C:275
 DCA.C:276
 DCA.C:277
 DCA.C:278
 DCA.C:279
 DCA.C:280
 DCA.C:281
 DCA.C:282
 DCA.C:283
 DCA.C:284
 DCA.C:285
 DCA.C:286
 DCA.C:287
 DCA.C:288
 DCA.C:289
 DCA.C:290
 DCA.C:291
 DCA.C:292
 DCA.C:293
 DCA.C:294
 DCA.C:295
 DCA.C:296
 DCA.C:297
 DCA.C:298
 DCA.C:299
 DCA.C:300
 DCA.C:301
 DCA.C:302
 DCA.C:303
 DCA.C:304
 DCA.C:305
 DCA.C:306
 DCA.C:307
 DCA.C:308
 DCA.C:309
 DCA.C:310
 DCA.C:311
 DCA.C:312
 DCA.C:313
 DCA.C:314
 DCA.C:315
 DCA.C:316
 DCA.C:317
 DCA.C:318
 DCA.C:319
 DCA.C:320
 DCA.C:321
 DCA.C:322
 DCA.C:323
 DCA.C:324
 DCA.C:325
 DCA.C:326
 DCA.C:327
 DCA.C:328
 DCA.C:329
 DCA.C:330
 DCA.C:331
 DCA.C:332
 DCA.C:333
 DCA.C:334
 DCA.C:335
 DCA.C:336
 DCA.C:337
 DCA.C:338
 DCA.C:339
 DCA.C:340
 DCA.C:341
 DCA.C:342
 DCA.C:343
 DCA.C:344
 DCA.C:345
 DCA.C:346
 DCA.C:347
 DCA.C:348
 DCA.C:349
 DCA.C:350
 DCA.C:351
 DCA.C:352
 DCA.C:353
 DCA.C:354
 DCA.C:355
 DCA.C:356
 DCA.C:357
 DCA.C:358
 DCA.C:359
 DCA.C:360
 DCA.C:361
 DCA.C:362
 DCA.C:363
 DCA.C:364
 DCA.C:365
 DCA.C:366
 DCA.C:367
 DCA.C:368
 DCA.C:369
 DCA.C:370
 DCA.C:371
 DCA.C:372
 DCA.C:373
 DCA.C:374
 DCA.C:375
 DCA.C:376
 DCA.C:377
 DCA.C:378
 DCA.C:379
 DCA.C:380
 DCA.C:381
 DCA.C:382
 DCA.C:383
 DCA.C:384
 DCA.C:385
 DCA.C:386
 DCA.C:387
 DCA.C:388
 DCA.C:389
 DCA.C:390
 DCA.C:391
 DCA.C:392
 DCA.C:393
 DCA.C:394
 DCA.C:395
 DCA.C:396
 DCA.C:397
 DCA.C:398
 DCA.C:399
 DCA.C:400
 DCA.C:401
 DCA.C:402
 DCA.C:403
 DCA.C:404
 DCA.C:405
 DCA.C:406
 DCA.C:407
 DCA.C:408
 DCA.C:409
 DCA.C:410
 DCA.C:411
 DCA.C:412
 DCA.C:413
 DCA.C:414
 DCA.C:415
 DCA.C:416
 DCA.C:417
 DCA.C:418
 DCA.C:419
 DCA.C:420
 DCA.C:421
 DCA.C:422
 DCA.C:423
 DCA.C:424
 DCA.C:425
 DCA.C:426
 DCA.C:427
 DCA.C:428
 DCA.C:429
 DCA.C:430
 DCA.C:431
 DCA.C:432
 DCA.C:433
 DCA.C:434
 DCA.C:435
 DCA.C:436
 DCA.C:437
 DCA.C:438
 DCA.C:439
 DCA.C:440
 DCA.C:441
 DCA.C:442
 DCA.C:443
 DCA.C:444
 DCA.C:445
 DCA.C:446
 DCA.C:447
 DCA.C:448
 DCA.C:449
 DCA.C:450
 DCA.C:451
 DCA.C:452
 DCA.C:453
 DCA.C:454
 DCA.C:455
 DCA.C:456
 DCA.C:457
 DCA.C:458
 DCA.C:459
 DCA.C:460
 DCA.C:461
 DCA.C:462
 DCA.C:463
 DCA.C:464
 DCA.C:465
 DCA.C:466
 DCA.C:467
 DCA.C:468
 DCA.C:469
 DCA.C:470
 DCA.C:471
 DCA.C:472
 DCA.C:473
 DCA.C:474
 DCA.C:475
 DCA.C:476
 DCA.C:477
 DCA.C:478
 DCA.C:479
 DCA.C:480
 DCA.C:481
 DCA.C:482
 DCA.C:483
 DCA.C:484
 DCA.C:485
 DCA.C:486
 DCA.C:487
 DCA.C:488
 DCA.C:489
 DCA.C:490
 DCA.C:491
 DCA.C:492
 DCA.C:493
 DCA.C:494
 DCA.C:495
 DCA.C:496
 DCA.C:497
 DCA.C:498
 DCA.C:499
 DCA.C:500
 DCA.C:501
 DCA.C:502
 DCA.C:503
 DCA.C:504
 DCA.C:505
 DCA.C:506
 DCA.C:507
 DCA.C:508
 DCA.C:509
 DCA.C:510
 DCA.C:511
 DCA.C:512
 DCA.C:513
 DCA.C:514
 DCA.C:515
 DCA.C:516
 DCA.C:517
 DCA.C:518
 DCA.C:519
 DCA.C:520
 DCA.C:521
 DCA.C:522
 DCA.C:523
 DCA.C:524
 DCA.C:525
 DCA.C:526
 DCA.C:527
 DCA.C:528
 DCA.C:529
 DCA.C:530
 DCA.C:531
 DCA.C:532
 DCA.C:533
 DCA.C:534
 DCA.C:535
 DCA.C:536
 DCA.C:537
 DCA.C:538
 DCA.C:539
 DCA.C:540
 DCA.C:541
 DCA.C:542
 DCA.C:543
 DCA.C:544
 DCA.C:545
 DCA.C:546
 DCA.C:547
 DCA.C:548
 DCA.C:549
 DCA.C:550
 DCA.C:551
 DCA.C:552
 DCA.C:553
 DCA.C:554
 DCA.C:555
 DCA.C:556
 DCA.C:557
 DCA.C:558
 DCA.C:559
 DCA.C:560
 DCA.C:561
 DCA.C:562
 DCA.C:563
 DCA.C:564
 DCA.C:565
 DCA.C:566
 DCA.C:567
 DCA.C:568
 DCA.C:569
 DCA.C:570
 DCA.C:571
 DCA.C:572
 DCA.C:573
 DCA.C:574
 DCA.C:575
 DCA.C:576
 DCA.C:577
 DCA.C:578
 DCA.C:579
 DCA.C:580
 DCA.C:581
 DCA.C:582
 DCA.C:583
 DCA.C:584
 DCA.C:585
 DCA.C:586
 DCA.C:587
 DCA.C:588
 DCA.C:589
 DCA.C:590
 DCA.C:591
 DCA.C:592
 DCA.C:593
 DCA.C:594
 DCA.C:595
 DCA.C:596
 DCA.C:597
 DCA.C:598
 DCA.C:599
 DCA.C:600
 DCA.C:601
 DCA.C:602
 DCA.C:603
 DCA.C:604
 DCA.C:605
 DCA.C:606
 DCA.C:607
 DCA.C:608
 DCA.C:609
 DCA.C:610
 DCA.C:611
 DCA.C:612
 DCA.C:613
 DCA.C:614
 DCA.C:615
 DCA.C:616
 DCA.C:617
 DCA.C:618
 DCA.C:619
 DCA.C:620
 DCA.C:621
 DCA.C:622
 DCA.C:623
 DCA.C:624
 DCA.C:625
 DCA.C:626
 DCA.C:627
 DCA.C:628
 DCA.C:629
 DCA.C:630
 DCA.C:631
 DCA.C:632
 DCA.C:633
 DCA.C:634
 DCA.C:635
 DCA.C:636
 DCA.C:637
 DCA.C:638
 DCA.C:639
 DCA.C:640
 DCA.C:641
 DCA.C:642
 DCA.C:643
 DCA.C:644
 DCA.C:645
 DCA.C:646
 DCA.C:647
 DCA.C:648
 DCA.C:649
 DCA.C:650
 DCA.C:651
 DCA.C:652
 DCA.C:653
 DCA.C:654
 DCA.C:655
 DCA.C:656
 DCA.C:657
 DCA.C:658
 DCA.C:659
 DCA.C:660
 DCA.C:661
 DCA.C:662
 DCA.C:663
 DCA.C:664
 DCA.C:665
 DCA.C:666
 DCA.C:667
 DCA.C:668
 DCA.C:669
 DCA.C:670
 DCA.C:671
 DCA.C:672
 DCA.C:673
 DCA.C:674
 DCA.C:675
 DCA.C:676
 DCA.C:677
 DCA.C:678
 DCA.C:679
 DCA.C:680
 DCA.C:681
 DCA.C:682
 DCA.C:683
 DCA.C:684
 DCA.C:685
 DCA.C:686
 DCA.C:687
 DCA.C:688
 DCA.C:689
 DCA.C:690
 DCA.C:691
 DCA.C:692
 DCA.C:693
 DCA.C:694
 DCA.C:695
 DCA.C:696
 DCA.C:697
 DCA.C:698
 DCA.C:699
 DCA.C:700
 DCA.C:701
 DCA.C:702
 DCA.C:703
 DCA.C:704
 DCA.C:705
 DCA.C:706
 DCA.C:707
 DCA.C:708
 DCA.C:709
 DCA.C:710
 DCA.C:711
 DCA.C:712
 DCA.C:713
 DCA.C:714
 DCA.C:715
 DCA.C:716
 DCA.C:717
 DCA.C:718
 DCA.C:719
 DCA.C:720
 DCA.C:721
 DCA.C:722
 DCA.C:723
 DCA.C:724
 DCA.C:725
 DCA.C:726
 DCA.C:727
 DCA.C:728
 DCA.C:729
 DCA.C:730
 DCA.C:731
 DCA.C:732
 DCA.C:733
 DCA.C:734
 DCA.C:735
 DCA.C:736
 DCA.C:737
 DCA.C:738
 DCA.C:739
 DCA.C:740
 DCA.C:741
 DCA.C:742
 DCA.C:743
 DCA.C:744
 DCA.C:745
 DCA.C:746
 DCA.C:747
 DCA.C:748
 DCA.C:749
 DCA.C:750
 DCA.C:751
 DCA.C:752
 DCA.C:753
 DCA.C:754
 DCA.C:755
 DCA.C:756
 DCA.C:757
 DCA.C:758
 DCA.C:759
 DCA.C:760
 DCA.C:761
 DCA.C:762
 DCA.C:763
 DCA.C:764
 DCA.C:765
 DCA.C:766
 DCA.C:767
 DCA.C:768
 DCA.C:769
 DCA.C:770
 DCA.C:771
 DCA.C:772
 DCA.C:773
 DCA.C:774
 DCA.C:775
 DCA.C:776
 DCA.C:777
 DCA.C:778
 DCA.C:779
 DCA.C:780
 DCA.C:781
 DCA.C:782
 DCA.C:783
 DCA.C:784
 DCA.C:785
 DCA.C:786
 DCA.C:787
 DCA.C:788
 DCA.C:789
 DCA.C:790
 DCA.C:791
 DCA.C:792
 DCA.C:793
 DCA.C:794
 DCA.C:795
 DCA.C:796
 DCA.C:797
 DCA.C:798
 DCA.C:799
 DCA.C:800
 DCA.C:801
 DCA.C:802
 DCA.C:803
 DCA.C:804
 DCA.C:805
 DCA.C:806
 DCA.C:807
 DCA.C:808
 DCA.C:809
 DCA.C:810
 DCA.C:811
 DCA.C:812
 DCA.C:813
 DCA.C:814
 DCA.C:815
 DCA.C:816
 DCA.C:817
 DCA.C:818
 DCA.C:819
 DCA.C:820
 DCA.C:821
 DCA.C:822
 DCA.C:823
 DCA.C:824
 DCA.C:825
 DCA.C:826
 DCA.C:827
 DCA.C:828
 DCA.C:829
 DCA.C:830
 DCA.C:831
 DCA.C:832
 DCA.C:833
 DCA.C:834
 DCA.C:835
 DCA.C:836
 DCA.C:837
 DCA.C:838
 DCA.C:839
 DCA.C:840
 DCA.C:841
 DCA.C:842
 DCA.C:843
 DCA.C:844
 DCA.C:845
 DCA.C:846
 DCA.C:847
 DCA.C:848
 DCA.C:849
 DCA.C:850
 DCA.C:851
 DCA.C:852
 DCA.C:853
 DCA.C:854
 DCA.C:855
 DCA.C:856
 DCA.C:857
 DCA.C:858
 DCA.C:859
 DCA.C:860
 DCA.C:861
 DCA.C:862
 DCA.C:863
 DCA.C:864
 DCA.C:865
 DCA.C:866
 DCA.C:867
 DCA.C:868
 DCA.C:869
 DCA.C:870
 DCA.C:871
 DCA.C:872
 DCA.C:873
 DCA.C:874
 DCA.C:875
 DCA.C:876
 DCA.C:877
 DCA.C:878
 DCA.C:879
 DCA.C:880
 DCA.C:881
 DCA.C:882
 DCA.C:883
 DCA.C:884
 DCA.C:885
 DCA.C:886
 DCA.C:887
 DCA.C:888
 DCA.C:889
 DCA.C:890
 DCA.C:891
 DCA.C:892
 DCA.C:893
 DCA.C:894
 DCA.C:895
 DCA.C:896
 DCA.C:897
 DCA.C:898
 DCA.C:899
 DCA.C:900
 DCA.C:901
 DCA.C:902
 DCA.C:903
 DCA.C:904
 DCA.C:905
 DCA.C:906
 DCA.C:907
 DCA.C:908
 DCA.C:909
 DCA.C:910
 DCA.C:911
 DCA.C:912
 DCA.C:913
 DCA.C:914
 DCA.C:915
 DCA.C:916
 DCA.C:917
 DCA.C:918
 DCA.C:919
 DCA.C:920
 DCA.C:921
 DCA.C:922
 DCA.C:923
 DCA.C:924
 DCA.C:925
 DCA.C:926
 DCA.C:927
 DCA.C:928
 DCA.C:929
 DCA.C:930
 DCA.C:931
 DCA.C:932
 DCA.C:933
 DCA.C:934
 DCA.C:935
 DCA.C:936
 DCA.C:937
 DCA.C:938
 DCA.C:939
 DCA.C:940
 DCA.C:941
 DCA.C:942
 DCA.C:943
 DCA.C:944
 DCA.C:945
 DCA.C:946
 DCA.C:947
 DCA.C:948
 DCA.C:949
 DCA.C:950
 DCA.C:951
 DCA.C:952
 DCA.C:953
 DCA.C:954
 DCA.C:955
 DCA.C:956
 DCA.C:957
 DCA.C:958
 DCA.C:959
 DCA.C:960
 DCA.C:961
 DCA.C:962
 DCA.C:963
 DCA.C:964
 DCA.C:965
 DCA.C:966
 DCA.C:967
 DCA.C:968
 DCA.C:969
 DCA.C:970
 DCA.C:971
 DCA.C:972
 DCA.C:973
 DCA.C:974
 DCA.C:975
 DCA.C:976
 DCA.C:977
 DCA.C:978
 DCA.C:979
 DCA.C:980
 DCA.C:981
 DCA.C:982
 DCA.C:983
 DCA.C:984
 DCA.C:985
 DCA.C:986
 DCA.C:987
 DCA.C:988
 DCA.C:989
 DCA.C:990
 DCA.C:991
 DCA.C:992
 DCA.C:993
 DCA.C:994
 DCA.C:995
 DCA.C:996
 DCA.C:997
 DCA.C:998
 DCA.C:999
 DCA.C:1000
 DCA.C:1001
 DCA.C:1002
 DCA.C:1003
 DCA.C:1004
 DCA.C:1005
 DCA.C:1006
 DCA.C:1007
 DCA.C:1008
 DCA.C:1009
 DCA.C:1010
 DCA.C:1011
 DCA.C:1012
 DCA.C:1013
 DCA.C:1014
 DCA.C:1015
 DCA.C:1016
 DCA.C:1017
 DCA.C:1018
 DCA.C:1019
 DCA.C:1020
 DCA.C:1021
 DCA.C:1022
 DCA.C:1023
 DCA.C:1024
 DCA.C:1025
 DCA.C:1026
 DCA.C:1027
 DCA.C:1028
 DCA.C:1029
 DCA.C:1030
 DCA.C:1031
 DCA.C:1032
 DCA.C:1033
 DCA.C:1034
 DCA.C:1035
 DCA.C:1036
 DCA.C:1037
 DCA.C:1038
 DCA.C:1039
 DCA.C:1040
 DCA.C:1041
 DCA.C:1042
 DCA.C:1043
 DCA.C:1044
 DCA.C:1045
 DCA.C:1046
 DCA.C:1047
 DCA.C:1048
 DCA.C:1049
 DCA.C:1050
 DCA.C:1051
 DCA.C:1052
 DCA.C:1053
 DCA.C:1054
 DCA.C:1055
 DCA.C:1056
 DCA.C:1057
 DCA.C:1058
 DCA.C:1059
 DCA.C:1060
 DCA.C:1061
 DCA.C:1062
 DCA.C:1063
 DCA.C:1064
 DCA.C:1065
 DCA.C:1066
 DCA.C:1067
 DCA.C:1068
 DCA.C:1069
 DCA.C:1070
 DCA.C:1071
 DCA.C:1072
 DCA.C:1073
 DCA.C:1074
 DCA.C:1075
 DCA.C:1076
 DCA.C:1077
 DCA.C:1078
 DCA.C:1079
 DCA.C:1080
 DCA.C:1081
 DCA.C:1082
 DCA.C:1083
 DCA.C:1084
 DCA.C:1085
 DCA.C:1086
 DCA.C:1087
 DCA.C:1088
 DCA.C:1089
 DCA.C:1090
 DCA.C:1091
 DCA.C:1092
 DCA.C:1093
 DCA.C:1094
 DCA.C:1095
 DCA.C:1096
 DCA.C:1097
 DCA.C:1098
 DCA.C:1099
 DCA.C:1100
 DCA.C:1101
 DCA.C:1102
 DCA.C:1103
 DCA.C:1104
 DCA.C:1105
 DCA.C:1106
 DCA.C:1107
 DCA.C:1108
 DCA.C:1109
 DCA.C:1110
 DCA.C:1111
 DCA.C:1112
 DCA.C:1113
 DCA.C:1114
 DCA.C:1115
 DCA.C:1116
 DCA.C:1117
 DCA.C:1118
 DCA.C:1119
 DCA.C:1120
 DCA.C:1121
 DCA.C:1122
 DCA.C:1123
 DCA.C:1124
 DCA.C:1125
 DCA.C:1126
 DCA.C:1127
 DCA.C:1128
 DCA.C:1129
 DCA.C:1130
 DCA.C:1131
 DCA.C:1132
 DCA.C:1133
 DCA.C:1134
 DCA.C:1135
 DCA.C:1136
 DCA.C:1137
 DCA.C:1138
 DCA.C:1139
 DCA.C:1140
 DCA.C:1141
 DCA.C:1142
 DCA.C:1143
 DCA.C:1144
 DCA.C:1145
 DCA.C:1146
 DCA.C:1147
 DCA.C:1148
 DCA.C:1149
 DCA.C:1150
 DCA.C:1151
 DCA.C:1152
 DCA.C:1153
 DCA.C:1154
 DCA.C:1155
 DCA.C:1156
 DCA.C:1157
 DCA.C:1158
 DCA.C:1159
 DCA.C:1160
 DCA.C:1161
 DCA.C:1162
 DCA.C:1163
 DCA.C:1164
 DCA.C:1165
 DCA.C:1166
 DCA.C:1167
 DCA.C:1168
 DCA.C:1169
 DCA.C:1170
 DCA.C:1171
 DCA.C:1172
 DCA.C:1173
 DCA.C:1174
 DCA.C:1175
 DCA.C:1176
 DCA.C:1177
 DCA.C:1178
 DCA.C:1179
 DCA.C:1180
 DCA.C:1181
 DCA.C:1182
 DCA.C:1183
 DCA.C:1184
 DCA.C:1185
 DCA.C:1186
 DCA.C:1187
 DCA.C:1188
 DCA.C:1189
 DCA.C:1190
 DCA.C:1191
 DCA.C:1192
 DCA.C:1193
 DCA.C:1194
 DCA.C:1195
 DCA.C:1196
 DCA.C:1197
 DCA.C:1198
 DCA.C:1199
 DCA.C:1200
 DCA.C:1201
 DCA.C:1202
 DCA.C:1203
 DCA.C:1204
 DCA.C:1205
 DCA.C:1206
 DCA.C:1207
 DCA.C:1208
 DCA.C:1209
 DCA.C:1210
 DCA.C:1211
 DCA.C:1212
 DCA.C:1213
 DCA.C:1214
 DCA.C:1215
 DCA.C:1216
 DCA.C:1217
 DCA.C:1218
 DCA.C:1219
 DCA.C:1220
 DCA.C:1221
 DCA.C:1222
 DCA.C:1223
 DCA.C:1224
 DCA.C:1225
 DCA.C:1226
 DCA.C:1227
 DCA.C:1228
 DCA.C:1229
 DCA.C:1230
 DCA.C:1231
 DCA.C:1232
 DCA.C:1233
 DCA.C:1234
 DCA.C:1235
 DCA.C:1236
 DCA.C:1237
 DCA.C:1238
 DCA.C:1239
 DCA.C:1240
 DCA.C:1241
 DCA.C:1242
 DCA.C:1243
 DCA.C:1244
 DCA.C:1245
 DCA.C:1246
 DCA.C:1247
 DCA.C:1248
 DCA.C:1249
 DCA.C:1250
 DCA.C:1251
 DCA.C:1252
 DCA.C:1253
 DCA.C:1254
 DCA.C:1255
 DCA.C:1256
 DCA.C:1257
 DCA.C:1258
 DCA.C:1259
 DCA.C:1260
 DCA.C:1261
 DCA.C:1262
 DCA.C:1263
 DCA.C:1264
 DCA.C:1265
 DCA.C:1266
 DCA.C:1267
 DCA.C:1268
 DCA.C:1269
 DCA.C:1270
 DCA.C:1271
 DCA.C:1272
 DCA.C:1273
 DCA.C:1274
 DCA.C:1275
 DCA.C:1276
 DCA.C:1277
 DCA.C:1278
 DCA.C:1279
 DCA.C:1280
 DCA.C:1281
 DCA.C:1282
 DCA.C:1283
 DCA.C:1284
 DCA.C:1285
 DCA.C:1286
 DCA.C:1287
 DCA.C:1288
 DCA.C:1289
 DCA.C:1290
 DCA.C:1291
 DCA.C:1292
 DCA.C:1293
 DCA.C:1294
 DCA.C:1295
 DCA.C:1296
 DCA.C:1297
 DCA.C:1298
 DCA.C:1299
 DCA.C:1300
 DCA.C:1301
 DCA.C:1302
 DCA.C:1303
 DCA.C:1304
 DCA.C:1305
 DCA.C:1306
 DCA.C:1307
 DCA.C:1308
 DCA.C:1309
 DCA.C:1310
 DCA.C:1311
 DCA.C:1312
 DCA.C:1313
 DCA.C:1314
 DCA.C:1315
 DCA.C:1316
 DCA.C:1317
 DCA.C:1318
 DCA.C:1319
 DCA.C:1320
 DCA.C:1321
 DCA.C:1322
 DCA.C:1323
 DCA.C:1324
 DCA.C:1325
 DCA.C:1326
 DCA.C:1327
 DCA.C:1328
 DCA.C:1329
 DCA.C:1330
 DCA.C:1331
 DCA.C:1332
 DCA.C:1333
 DCA.C:1334
 DCA.C:1335
 DCA.C:1336
 DCA.C:1337
 DCA.C:1338
 DCA.C:1339
 DCA.C:1340
 DCA.C:1341
 DCA.C:1342
 DCA.C:1343
 DCA.C:1344
 DCA.C:1345
 DCA.C:1346
 DCA.C:1347
 DCA.C:1348
 DCA.C:1349
 DCA.C:1350
 DCA.C:1351
 DCA.C:1352
 DCA.C:1353
 DCA.C:1354
 DCA.C:1355
 DCA.C:1356
 DCA.C:1357
 DCA.C:1358
 DCA.C:1359
 DCA.C:1360
 DCA.C:1361
 DCA.C:1362
 DCA.C:1363
 DCA.C:1364
 DCA.C:1365
 DCA.C:1366
 DCA.C:1367
 DCA.C:1368
 DCA.C:1369
 DCA.C:1370
 DCA.C:1371
 DCA.C:1372
 DCA.C:1373
 DCA.C:1374
 DCA.C:1375
 DCA.C:1376
 DCA.C:1377
 DCA.C:1378
 DCA.C:1379
 DCA.C:1380
 DCA.C:1381
 DCA.C:1382
 DCA.C:1383
 DCA.C:1384
 DCA.C:1385
 DCA.C:1386
 DCA.C:1387
 DCA.C:1388
 DCA.C:1389
 DCA.C:1390
 DCA.C:1391
 DCA.C:1392
 DCA.C:1393