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

//Functions used by the other macros
//Author: Jason Glyndwr Ulery, ulery@uni-frankfurt.de

void MakeProjections(Float_t &xTPt1, Float_t &xTPt2, Float_t &xAPt1, Float_t &xAPt2, Int_t xCent, TList *xList, TH1F *xOutHistPhi, TH1F *xOutHistPhiMix, TH1F *xOutHistEtaN, TH1F *xOutHistEtaNMix, TH1F *xOutHistEtaA, TH1F *xOutHistEtaAMix, TH2F *xOutHistPhiEta, TH2F *xOutHistPhiEtaMix, Float_t xMPt[4], Int_t xptweighted=0, Int_t xMC=0, Int_t xNotDelta=0, Int_t xSign=0){//(Trigger Pt Low, Trigger Pt High, Assoc Pt Low, Assoc Pt High, Centrality Bin, List, Hists, mean pt array, Pt weighted?, Monty Carlo?, gives phi from triggered and from all for delta phi and delta phi mixed respectively) 
  // TFile *xFile=new TFile(xFileName);
  //TList *xList=xFile->Get("julery_DiHadron");
  //This needs changed if Input binning is changed
  //cout << xptweighted << " " << xMC << " " << xNotDelta << " " << xSign << endl;
  const int xnpt=12;
  //float xptbins[(xnpt+1)]={2.5,3,4,6,8,10,15,20,30,40,50,75,100};
  //IF you change also change in EffFit
  float xptbins[(xnpt+1)]={2,2.5,3,4,5,6,8,10,15,20,30,40,50};
  const int xapt=30;
  float xaptbins[(xapt+1)]={0.25,0.5,0.75,1,1.5,2,2.5,3,3.5,4,4.5,5,6,7,8,9,10,12,15,20,25,30,35,40,45,50,60,70,80,90,100};
  float xPi=3.1415926535898;
  
  //After this no changes should be needed
  float xsum1,xsum2,xerr1,xerr2;
  int xtpt1=-1,xtpt2=-1;
  TH2F *xtemphist1;
  TH2F *xtemphist2;
  TH3F *xtemphist3;
  TH3F *xtemphist4;
  TH2F *xtemphistEN;
  TH2F *xtemphistENM;
  TH2F *xtemphistEA;
  TH2F *xtemphistEAM;
  int xapt1,xapt2,xapt3,xapt4;
  
  for(int xi=0;xi<=xnpt;xi++){
    if(fabs(xTPt1-xptbins[xi])<0.2)xtpt1=xi;
    if(fabs(xTPt2-xptbins[xi])<0.2)xtpt2=xi;
  }
  //cout << xtpt1 << " " << xtpt2 << endl;
  if(xtpt1<0)cout << "Invalid Trigger Pt1" << endl;
  if(xtpt2<0)cout << "Invalid Trigger Pt2" << endl;
  if(xtpt1<0||xtpt2<0)break;
  
  
  if(xAPt2>xTPt1){
    cout << "Associateds must be less then trigger (Automatically forced)" << endl;
    xAPt2=xTPt1;
  }
  for(int xi=0;xi<=xapt;xi++){
    if(fabs(xAPt1-xaptbins[xi])<0.1)xapt1=xi+1;
    if(fabs(xAPt2-xaptbins[xi])<0.1)xapt2=xi;
  }
  // cout << xapt1 << " " << xapt2 << endl;
  //since there are some tolerences reset the values to what are actually used
  // xAPt1=(xapt1-1)*xasswidth;
  // xAPt2=(xapt2-1)*xasswidth;
  xAPt1=xaptbins[xapt1-1];
  xAPt2=xaptbins[xapt2];
  xTPt1=xptbins[xtpt1];
  xTPt2=xptbins[xtpt2];
  cout << "xTPt: "<< xTPt1 <<  " - " << xTPt2 << endl; 
  cout << "xAPt: " << xAPt1 << " - " << xAPt2 << endl;
  float xntrig=0,xnmix=0,xntrigpt=0;
  float exntrig=0,exntrigpt=0;
  char xname[150];
  char *cpt1[2]={"","Pt"};
  char *cdelta2[2]={"DeltaPhiEta","PhiEtaTrig"};
  char *cdelta1[2]={"DeltaPhi","PhiTrig"};
  char *cmc1[2]={"","_MC"};
  char *sign1[3]={"","_LS","_ULS"};
  char *sign2[3]={""," LikeSign"," UnlikeSign"};
  char *xEtaN[2]={"DeltaEtaN","EtaTrig"};
  char *xEtaA[2]={"DeltaEtaA","EtaTrig"};
  
  
  sprintf(xname,"fHistNTrigger_C%d%s",xCent,cmc1[xMC]);
  TH1F *xNTrig=(TH1F*)xList->FindObject(xname);
  sprintf(xname,"fHistNMix_C%d%s",xCent,cmc1[xMC]);
  TH1F *xNMix=(TH1F*)xList->FindObject(xname);
  sprintf(xname,"fHistNTriggerPt_C%d%s",xCent,cmc1[xMC]);
  TH1F *xNTrigPt=(TH1F*)xList->FindObject(xname);
  sprintf(xname,"fHistMult%s",cmc1[xMC]);
  TH1F *xMult=(TH1F*)xList->FindObject(xname);
  int xnevent=xMult->GetEntries();
  
  for(int xi=xtpt1;xi<xtpt2;xi++){//Do for all trigger pt ranges we are adding
    sprintf(xname,"fHist%s%s_P%d_C%d%s%s",cdelta1[xNotDelta],cpt1[xptweighted],xi,xCent,sign1[xSign],cmc1[xMC]);
    xtemphist1=(TH2F*)xList->FindObject(xname);
    sprintf(xname,"fHistDeltaPhiMix%s_P%d_C%d%s%s",cpt1[xptweighted],xi,xCent,sign1[xSign],cmc1[xMC]);
    if(xNotDelta) sprintf(xname,"fHistPhi%s_C%d%s",cpt1[xptweighted],xCent,cmc1[xMC]);
    xtemphist2=(TH2F*)xList->FindObject(xname);
    
    sprintf(xname,"fHist%s%s_P%d_C%d%s%s",xEtaN[xNotDelta],cpt1[xptweighted],xi,xCent,sign1[xSign],cmc1[xMC]);
    xtemphistEN=(TH2F*)xList->FindObject(xname);
    
    sprintf(xname,"fHistDeltaEtaNMix%s_P%d_C%d%s%s",cpt1[xptweighted],xi,xCent,sign1[xSign],cmc1[xMC]);
    if(xNotDelta) sprintf(xname,"fHistEta%s_C%d%s",cpt1[xptweighted],xCent,cmc1[xMC]);
    xtemphistENM=(TH2F*)xList->FindObject(xname);
    
    
    sprintf(xname,"fHist%s%s_P%d_C%d%s%s",xEtaA[xNotDelta],cpt1[xptweighted],xi,xCent,sign1[xSign],cmc1[xMC]);
    xtemphistEA=(TH2F*)xList->FindObject(xname);
    sprintf(xname,"fHistDeltaEtaAMix%s_P%d_C%d%s%s",cpt1[xptweighted],xi,xCent,sign1[xSign],cmc1[xMC]);
    if(xNotDelta) sprintf(xname,"fHistEta%s_C%d%s",cpt1[xptweighted],xCent,cmc1[xMC]);
    xtemphistEAM=(TH2F*)xList->FindObject(xname);
    
    sprintf(xname,"fHist%s%s_P%d_C%d%s",cdelta2[xNotDelta],cpt1[xptweighted],xi,xCent,cmc1[xMC]);
    xtemphist3=(TH3F*)xList->FindObject(xname);
    sprintf(xname,"fHistDeltaPhiEtaMix%s_P%d_C%d%s",cpt1[xptweighted],xi,xCent,cmc1[xMC]);
    if(xNotDelta) sprintf(xname,"fHistPhiEta%s_C%d%s",cpt1[xptweighted],xCent,cmc1[xMC]);
    xtemphist4=(TH3F*)xList->FindObject(xname);
    //c12355=new TCanvas("c12355","c12355");
    // xtemphist4->Draw();
    
    xntrig+=xNTrig->GetBinContent(xi+1);
    xnmix+=xNMix->GetBinContent(xi+1);
    exntrig+=pow(xNTrig->GetBinError(xi+1),2);
    xntrigpt+=xNTrigPt->GetBinContent(xi+1);
    exntrigpt+=pow(xNTrigPt->GetBinError(xi+1),2);
    if(xi==xtpt1){
      TH2F *xDeltaPhi=(TH2F*)xtemphist1->Clone();
      xDeltaPhi->SetName("xDeltaPhi");
      TH2F *xDeltaPhiMix=(TH2F*)xtemphist2->Clone();
      xDeltaPhiMix->SetName("xDeltaPhiMix");
      int xnbins=xDeltaPhi->GetNbinsX();
      float xmin=xDeltaPhi->GetBinCenter(1)-(xDeltaPhi->GetBinWidth(1))/2.;
      float xmax=xDeltaPhi->GetBinCenter(xnbins)+(xDeltaPhi->GetBinWidth(xnbins))/2.;
      
      TH2F *xDeltaEtaN=(TH2F*)xtemphistEN->Clone();
      xDeltaEtaN->SetName("xDeltaEtaN");
      
      TH2F *xDeltaEtaNMix=(TH2F*)xtemphistENM->Clone();
      xDeltaEtaNMix->SetName("xDeltaEtaNMix");
      int xnEbins=xDeltaEtaN->GetNbinsX();
      //cout << xnEbins << "EtaBins" << endl;
      float xEmin=xDeltaEtaN->GetBinCenter(1)-(xDeltaEtaN->GetBinWidth(1))/2.;
      float xEmax=xDeltaEtaN->GetBinCenter(xnEbins)+(xDeltaEtaN->GetBinWidth(xnEbins))/2.; 
      
      TH2F *xDeltaEtaA=(TH2F*)xtemphistEA->Clone();
      xDeltaEtaA->SetName("xDeltaEtaA");
      TH2F *xDeltaEtaAMix=(TH2F*)xtemphistEAM->Clone();
      xDeltaEtaAMix->SetName("xDeltaEtaAMix");
      
      TH3F *xDeltaPhiEta=(TH3F*)xtemphist3->Clone();
      xDeltaPhiEta->SetName("xDeltaPhiEta");
      TH3F *xDeltaPhiEtaMix=(TH3F*)xtemphist4->Clone();
      xDeltaPhiEtaMix->SetName("xDeltaPhiEtaMix");
      TAxis *xAxis=xDeltaPhiEta->GetXaxis();
      TAxis *xAxis2=xDeltaPhiEta->GetXaxis();
      TAxis *yAxis2=xDeltaPhiEta->GetYaxis();
      int xnbins2=xAxis2->GetNbins();
      int ynbins2=yAxis2->GetNbins();
      float xmin2=xAxis2->GetBinCenter(1)-(xAxis2->GetBinWidth(1))/2.;
      float xmax2=xAxis2->GetBinCenter(xnbins2)+(xAxis2->GetBinWidth(xnbins2))/2.;
      float ymin2=yAxis2->GetBinCenter(1)-(yAxis2->GetBinWidth(1))/2.;
      float ymax2=yAxis2->GetBinCenter(ynbins2)+(yAxis2->GetBinWidth(ynbins2))/2.;
      //cout << "Sum Phi " << xDeltaPhi->GetSum() << endl;
    }
    else{
      for(int xj=1;xj<=xnbins;xj++){
	for(int xk=xapt1;xk<=xapt2;xk++){
	  xDeltaPhi->SetBinContent(xj,xk,(xDeltaPhi->GetBinContent(xj,xk)+xtemphist1->GetBinContent(xj,xk)));
	  xDeltaPhi->SetBinError(xj,xk,sqrt(pow(xDeltaPhi->GetBinError(xj,xk),2)+pow(xtemphist1->GetBinError(xj,xk),2)));
	  if(!xNotDelta)xDeltaPhiMix->SetBinContent(xj,xk,(xDeltaPhiMix->GetBinContent(xj,xk)+xtemphist2->GetBinContent(xj,xk)));
	  if(!xNotDelta)xDeltaPhiMix->SetBinError(xj,xk,sqrt(pow(xDeltaPhiMix->GetBinError(xj,xk),2)+pow(xtemphist2->GetBinError(xj,xk),2)));			
	}
      }//end phi loop
      
      for(int xj=1;xj<=xnEbins;xj++){
	for(int xk=xapt1;xk<=xapt2;xk++){
	  xDeltaEtaN->SetBinContent(xj,xk,(xDeltaEtaN->GetBinContent(xj,xk)+xtemphistEN->GetBinContent(xj,xk)));
	  xDeltaEtaN->SetBinError(xj,xk,sqrt(pow(xDeltaEtaN->GetBinError(xj,xk),2)+pow(xtemphistEN->GetBinError(xj,xk),2)));
	  if(!xNotDelta)xDeltaEtaNMix->SetBinContent(xj,xk,(xDeltaEtaNMix->GetBinContent(xj,xk)+xtemphistENM->GetBinContent(xj,xk)));
	  if(!xNotDelta)xDeltaEtaNMix->SetBinError(xj,xk,sqrt(pow(xDeltaEtaNMix->GetBinError(xj,xk),2)+pow(xtemphistENM->GetBinError(xj,xk),2)));
	  
	  xDeltaEtaA->SetBinContent(xj,xk,(xDeltaEtaA->GetBinContent(xj,xk)+xtemphistEA->GetBinContent(xj,xk)));
	  xDeltaEtaA->SetBinError(xj,xk,sqrt(pow(xDeltaEtaA->GetBinError(xj,xk),2)+pow(xtemphistEA->GetBinError(xj,xk),2)));
	  if(!xNotDelta)xDeltaEtaAMix->SetBinContent(xj,xk,(xDeltaEtaAMix->GetBinContent(xj,xk)+xtemphistEAM->GetBinContent(xj,xk)));
	  if(!xNotDelta)xDeltaEtaAMix->SetBinError(xj,xk,sqrt(pow(xDeltaEtaAMix->GetBinError(xj,xk),2)+pow(xtemphistEAM->GetBinError(xj,xk),2)));
	}
      }//end eta loop
      
      for(int xj=1;xj<=xnbins2;xj++){
	for(int xk=1;xk<=ynbins2;xk++){
	  for(int xl=xapt1;xl<=xapt2;xl++){
	    xDeltaPhiEta->SetBinContent(xj,xk,xl,(xDeltaPhiEta->GetBinContent(xj,xk,xl)+xtemphist3->GetBinContent(xj,xk,xl)));
	    xDeltaPhiEta->SetBinError(xj,xk,xl,sqrt(pow(xDeltaPhiEta->GetBinError(xj,xk,xl),2)+pow(xtemphist3->GetBinError(xj,xk,xl),2)));
	    if(!xNotDelta)xDeltaPhiEtaMix->SetBinContent(xj,xk,xl,(xDeltaPhiEtaMix->GetBinContent(xj,xk,xl)+xtemphist4->GetBinContent(xj,xk,xl)));
	    if(!xNotDelta)xDeltaPhiEtaMix->SetBinError(xj,xk,xl,sqrt(pow(xDeltaPhiEtaMix->GetBinError(xj,xk,xl),2)+pow(xtemphist4->GetBinError(xj,xk,xl),2)));
	  }
	}
      }//end eta-phi loop
    }//else
  }//xi 
  
  /*
    c124=new TCanvas("c124");
    xtemphist4->Draw();
    cout << xtemphist4->GetBinContent(10,10,2) << " " << xDeltaPhiEtaMix->GetBinContent(10,10,2) << endl;
    cout << xtemphist4->GetBinError(10,10,2) << " " << xDeltaPhiEtaMix->GetBinError(10,10,2) << endl;
    cout << xtemphist4->GetBinContent(10,1,2) << " " << xDeltaPhiEtaMix->GetBinContent(10,1,2) << endl;
  */
  
  
  cout << "Number of Triggers: " << xntrig << endl;
  cout << "Number of Mixed Events: " << xnmix << endl;
  sprintf(xname,"fHistNEvents_C%d",xCent);
  TH1F *xNEvents=(TH1F*)xList->FindObject(xname);
  cout << "Number of Events: " << xNEvents->GetBinContent(1) << endl;
  if(xptweighted)cout << "<P_T Trigger>: " << xntrigpt/xntrig << endl;
  //cout << xntrigpt << " " << exntrigpt << " " << xntrig << " " << exntrig << endl;
  if(xptweighted)xMPt[0]=xntrigpt/xntrig;
  exntrigpt=sqrt(exntrigpt);
  exntrig=sqrt(exntrig);
  if(xptweighted)xMPt[1]=xMPt[0]*sqrt(pow(exntrigpt/xntrigpt,2)+pow(exntrig/xntrig,2));
  xMPt[2]=xntrig;
  xMPt[3]=xnmix;
  xDeltaPhi->Scale(xnbins/(2.*xPi)/xntrig);
  xDeltaEtaN->Scale(xnEbins/(xEmax-xEmin)/xntrig);
  xDeltaEtaA->Scale(xnEbins/(xEmax-xEmin)/xntrig);
  xDeltaPhiEta->Scale(xnbins2/(2.*xPi)*ynbins2/(ymax2-ymin2)/xntrig);
  if(!xNotDelta){
    xDeltaPhiMix->Scale(xnbins/(2.*xPi)/xnmix);
    xDeltaEtaNMix->Scale(xnEbins/(xEmax-xEmin)/xnmix);
    xDeltaEtaAMix->Scale(xnEbins/(xEmax-xEmin)/xnmix);
    xDeltaPhiEtaMix->Scale(xnbins2/(2.*xPi)*ynbins2/(ymax2-ymin2)/xnmix);
  }
  else{
    xDeltaPhiMix->Scale(xnbins/(2.*xPi)/xnevent);
    xDeltaEtaNMix->Scale(xnEbins/(xEmax-xEmin)/xnevent);
    xDeltaEtaAMix->Scale(xnEbins/(xEmax-xEmin)/xnevent);
    xDeltaPhiEtaMix->Scale(xnbins2/(2.*xPi)*ynbins2/(ymax2-ymin2)/xnevent);
  }
  
  char *tit1="#Delta#phi";
  if(xNotDelta)tit1="#phi";
  char *tit11="";
  if(xptweighted)tit11="p_{T} Weighted";
  char *tit12="";
  if(xNotDelta)tit12="Triggered";
  char *tit2="1";
  if(xptweighted)tit2="p_{T}";
  char *tit3="Mixed #Delta#phi";
  if(xNotDelta)tit3="#phi";
  
  sprintf(xname,"%s %s %s Distribution for %3.1f<p_{T}^{Trig}<%3.1f %2.2f<p_{T}^{Assoc}<%2.2f%s",tit12,tit11,tit1,xTPt1,xTPt2,xAPt1,xAPt2,sign2[xSign]);
  *xOutHistPhi=new TH1F("dPhi",xname,xnbins,xmin,xmax);
  xOutHistPhi->Sumw2();
  sprintf(xname,"%s (radians)     ",tit1);
  xOutHistPhi->GetXaxis()->SetTitle(xname);
  sprintf(xname,"#frac{%s}{N_{Trig}}#frac{dN}{d%s}   ",tit2,tit1);
  xOutHistPhi->GetYaxis()->SetTitle(xname);
  SetTitles1D(xOutHistPhi);
  xOutHistPhi->SetMarkerStyle(20);
  xOutHistPhi->SetMarkerColor(2);
  xOutHistPhi->SetLineColor(2);
  
  sprintf(xname,"%s %s Distribution for %3.1f<p_{T}^{Trig}<%3.1f %2.2f<p_{T}^{Assoc}<%2.2f%s",tit11,tit3, xTPt1,xTPt2,xAPt1,xAPt2,sign2[xSign]);
  *xOutHistPhiMix=new TH1F("dMix",xname,xnbins,xmin,xmax);
  xOutHistPhiMix->Sumw2();
  sprintf(xname,"%s (radians)     ",tit1);
  xOutHistPhiMix->GetXaxis()->SetTitle(xname);
  sprintf(xname,"#frac{%s}{N_{Trig}}#frac{dN}{d%s}   ",tit2,tit1);
  xOutHistPhiMix->GetYaxis()->SetTitle(xname);
  SetTitles1D(xOutHistPhiMix);
  xOutHistPhiMix->SetMarkerStyle(21);
  xOutHistPhiMix->SetMarkerColor(1);
  xOutHistPhiMix->SetLineColor(1);
  
  char *tit14="#Delta#eta";
  if(xNotDelta) tit14="#eta";
  char *tit15="Mixed #Delta#eta";
  if(xNotDelta) tit15="#eta";
  char *titNear="Near-Side";
  if(xNotDelta)titNear="";
  
  sprintf(xname,"%s %s %s %s Distribution for %3.1f<p_{T}^{Trig}<%3.1f %2.2f<p_{T}^{Assoc}<%2.2f%s",tit12,titNear,tit11,tit14,xTPt1,xTPt2,xAPt1,xAPt2,sign2[xSign]);
  *xOutHistEtaN=new TH1F("dEtaN",xname,xnEbins,xEmin,xEmax);
  xOutHistEtaN->Sumw2();
  sprintf(xname,"%s     ",tit14);
  xOutHistEtaN->GetXaxis()->SetTitle(xname);
  sprintf(xname,"#frac{%s}{N_{Trig}}#frac{dN}{d%s}   ",tit2,tit14);
  xOutHistEtaN->GetYaxis()->SetTitle(xname);
  SetTitles1D(xOutHistEtaN);
  xOutHistEtaN->SetMarkerStyle(20);
  xOutHistEtaN->SetMarkerColor(2);
  xOutHistEtaN->SetLineColor(2);
  
  sprintf(xname,"%s %s %s Distribution for %3.1f<p_{T}^{Trig}<%3.1f %2.2f<p_{T}^{Assoc}<%2.2f%s",tit11,titNear,tit15,xTPt1,xTPt2,xAPt1,xAPt2,sign2[xSign]);
  *xOutHistEtaNMix=new TH1F("dEtaMixN",xname,xnEbins,xEmin,xEmax);
  xOutHistEtaNMix->Sumw2();
  sprintf(xname,"%s (radians)     ",tit1);
  xOutHistEtaNMix->GetXaxis()->SetTitle(xname);
  sprintf(xname,"#frac{%s}{N_{Trig}}#frac{dN}{d%s}   ",tit2,tit14);
  xOutHistEtaNMix->GetYaxis()->SetTitle(xname);
  SetTitles1D(xOutHistEtaNMix);
  xOutHistEtaNMix->SetMarkerStyle(21);
  xOutHistEtaNMix->SetMarkerColor(1);
  xOutHistEtaNMix->SetLineColor(1);
  
  char *titAway="Away-Side";
  if(xNotDelta)titAway="";
  
  sprintf(xname,"%s %s %s %s Distribution for %3.1f<p_{T}^{Trig}<%3.1f %2.2f<p_{T}^{Assoc}<%2.2f%s",tit12,titAway,tit11,tit14,xTPt1,xTPt2,xAPt1,xAPt2,sign2[xSign]);
  *xOutHistEtaA=new TH1F("dEtaA",xname,xnEbins,xEmin,xEmax);
  xOutHistEtaA->Sumw2();
  sprintf(xname,"%s     ",tit14);
  xOutHistEtaA->GetXaxis()->SetTitle(xname);
  sprintf(xname,"#frac{%s}{N_{Trig}}#frac{dN}{d%s}   ",tit2,tit14);
  xOutHistEtaA->GetYaxis()->SetTitle(xname);
  SetTitles1D(xOutHistEtaA);
  xOutHistEtaA->SetMarkerStyle(20);
  xOutHistEtaA->SetMarkerColor(2);
  xOutHistEtaA->SetLineColor(2);
  
  sprintf(xname,"%s %s %s Distribution for %3.1f<p_{T}^{Trig}<%3.1f %2.2f<p_{T}^{Assoc}<%2.2f%s",tit11,titAway,tit15,xTPt1,xTPt2,xAPt1,xAPt2,sign2[xSign]);
  *xOutHistEtaAMix=new TH1F("dEtaMixA",xname,xnEbins,xEmin,xEmax);
  xOutHistEtaAMix->Sumw2();
  sprintf(xname,"%s (radians)     ",tit1);
  xOutHistEtaAMix->GetXaxis()->SetTitle(xname);
  sprintf(xname,"#frac{%s}{N_{Trig}}#frac{dN}{d%s}   ",tit2,tit14);
  xOutHistEtaAMix->GetYaxis()->SetTitle(xname);
  SetTitles1D(xOutHistEtaAMix);
  xOutHistEtaAMix->SetMarkerStyle(21);
  xOutHistEtaAMix->SetMarkerColor(1);
  xOutHistEtaAMix->SetLineColor(1);
  
  sprintf(xname,"%s %s %s-%s Distribution for %3.1f<p_{T}^{Trig}<%3.1f %2.2f<p_{T}^{Assoc}<%2.2f%s",tit12,tit11,tit1,tit14,xTPt1,xTPt2,xAPt1,xAPt2,sign2[xSign]);
  *xOutHistPhiEta=new TH2F("dPhiEta",xname,xnbins2,xmin2,xmax2,ynbins2,ymin2,ymax2);
  xOutHistPhiEta->Sumw2();
  sprintf(xname,"%s (radians)     ",tit1);
  xOutHistPhiEta->GetXaxis()->SetTitle(xname);
  sprintf(xname,"%s     ",tit14);
  xOutHistPhiEta->GetYaxis()->SetTitle(xname);
  sprintf(xname,"#frac{%s}{N_{Trig}}#frac{dN}{d%sd%s}   ",tit2,tit1,tit14);
  xOutHistPhiEta->GetZaxis()->SetTitle(xname);
  SetTitles2D(xOutHistPhiEta);
  
  sprintf(xname,"%s %s-%s Distribution for %3.1f<p_{T}^{Trig}<%3.1f %2.2f<p_{T}^{Assoc}<%2.2f%s",tit11,tit3,tit14,xTPt1,xTPt2,xAPt1,xAPt2,sign2[xSign]);
  *xOutHistPhiEtaMix=new TH2F("dPhiEtaMix",xname,xnbins2,xmin2,xmax2,ynbins2,ymin2,ymax2);
  xOutHistPhiEtaMix->Sumw2();
  sprintf(xname,"%s (radians)     ",tit1);
  xOutHistPhiEtaMix->GetXaxis()->SetTitle(xname);
  sprintf(xname,"%s     ",tit14);
  xOutHistPhiEtaMix->GetYaxis()->SetTitle(xname);
  sprintf(xname,"#frac{%s}{N_{Trig}}#frac{dN}{d%sd%s}   ",tit2,tit1,tit14);
  xOutHistPhiEtaMix->GetZaxis()->SetTitle(xname);
  SetTitles2D(xOutHistPhiEtaMix);
  
  float xsum1,xsum2,xerr1,xerr2,xsum3,xsum4,xerr3,xerr4;
  for(int xi=1;xi<=xnbins;xi++){
    xsum1=0; xerr1=0; xsum2=0; xerr2=0;
    for(int xj=xapt1; xj<=xapt2;xj++){
      xsum1+=xDeltaPhi->GetBinContent(xi,xj);
      xerr1+=pow(xDeltaPhi->GetBinError(xi,xj),2);
      xsum2+=xDeltaPhiMix->GetBinContent(xi,xj);
      xerr2+=pow(xDeltaPhiMix->GetBinError(xi,xj),2);
    }
    
    xOutHistPhi->SetBinContent(xi,xsum1);
    xOutHistPhi->SetBinError(xi,sqrt(xerr1));
    xOutHistPhiMix->SetBinContent(xi,xsum2);
    xOutHistPhiMix->SetBinError(xi,sqrt(xerr2));
  }//philoop
  for(int xi=1;xi<=xnEbins;xi++){
    xsum1=0; xerr1=0; xsum2=0; xerr2=0; 
    xsum3=0; xerr3=0; xsum4=0; xerr4=0;
    //cout << "apt" << xapt1 << " " << xapt2 << endl;
    for(int xj=xapt1; xj<=xapt2;xj++){
      xsum1+=xDeltaEtaN->GetBinContent(xi,xj);
      xerr1+=pow(xDeltaEtaN->GetBinError(xi,xj),2);
      xsum2+=xDeltaEtaNMix->GetBinContent(xi,xj);
      xerr2+=pow(xDeltaEtaNMix->GetBinError(xi,xj),2);
      xsum3+=xDeltaEtaA->GetBinContent(xi,xj);
      xerr3+=pow(xDeltaEtaA->GetBinError(xi,xj),2);
      xsum4+=xDeltaEtaAMix->GetBinContent(xi,xj);
      xerr4+=pow(xDeltaEtaAMix->GetBinError(xi,xj),2);
    }
    xOutHistEtaN->SetBinContent(xi,xsum1);
    xOutHistEtaN->SetBinError(xi,sqrt(xerr1));
    xOutHistEtaNMix->SetBinContent(xi,xsum2);
    xOutHistEtaNMix->SetBinError(xi,sqrt(xerr2));
    xOutHistEtaA->SetBinContent(xi,xsum3);
    xOutHistEtaA->SetBinError(xi,sqrt(xerr3));
    xOutHistEtaAMix->SetBinContent(xi,xsum4);
    xOutHistEtaAMix->SetBinError(xi,sqrt(xerr4));
  }//etaloop
  
  for(int xi=1;xi<=xnbins2;xi++){
    for(int xj=1;xj<=ynbins2;xj++){
      xsum1=0; xerr1=0; xsum2=0; xerr2=0;
      for(int xk=xapt1; xk<=xapt2;xk++){
        xsum1+=xDeltaPhiEta->GetBinContent(xi,xj,xk);
	xerr1+=pow(xDeltaPhiEta->GetBinError(xi,xj,xk),2);
	xsum2+=xDeltaPhiEtaMix->GetBinContent(xi,xj,xk);
	xerr2+=pow(xDeltaPhiEtaMix->GetBinError(xi,xj,xk),2);
      }
      //cout << xDeltaPhiEtaMix->GetYaxis()->GetBinCenter(xj) << " " << xOutHistPhiEtaMix->GetYaxis()->GetBinCenter(xj) << " " << xsum2 << endl;
      xOutHistPhiEta->SetBinContent(xi,xj,xsum1);
      xOutHistPhiEta->SetBinError(xi,xj,sqrt(xerr1));
      xOutHistPhiEtaMix->SetBinContent(xi,xj,xsum2);
      xOutHistPhiEtaMix->SetBinError(xi,xj,sqrt(xsum2));
    }
  }//phi-eta loop
  
  //c10=new TCanvas("c10","",800,600);
  //xOutHistPhi->Draw();
  //delete xDeltaPhi;
  // delete xDeltaMix;
  //delete xtemphist1;
  //delete xtemphist2;
  //xFile->Close();
  
}

//--------------------------------------------------------------------------------------------------------		 

void ZYA1(TH1F *yHistSig, TH1F *yHistBg, float scalea[3], float ZYAMCent=1.,float ZYAMWidth=0.2){
  //yerr=0 no error
  //yerr=1 no mixed event
  //yerr=2 no signal
  //yerr=3 no signal and no mixed
  
  //float ZYAMCent=1.3;
  //float ZYAMWidth=0.2;//window is cent +/- width so its really a 1/2 width of the window
  float a,yea,yerr;
  //static float scalea[3];
  float ysumsig=0,ysumbg=0,yerrsig=0,yerrbg=0;
  float ycent;
  int ybins=yHistSig->GetNbinsX();
  float yPi=3.1415926535898;
  //cout << ybins << endl;
  //cout << yHistSig->GetSum() << endl;
  //c20=new TCanvas("c20","",800,600);
  //yHistSig->Draw();
  cout << "ZYAMRegion: " << (ZYAMCent-ZYAMWidth) << "-" << (ZYAMCent+ZYAMWidth) << endl;
  
  for(int yi=1;yi<=ybins;yi++){
    ycent=yHistSig->GetBinCenter(yi);
    if((fabs(fabs(ycent)-ZYAMCent)<ZYAMWidth)||(fabs(fabs(ycent)-(2*yPi-ZYAMCent))<ZYAMWidth)){
      ysumsig+=yHistSig->GetBinContent(yi);
      yerrsig+=pow(yHistSig->GetBinError(yi),2);
      ysumbg+=yHistBg->GetBinContent(yi);
      yerrbg+=pow(yHistBg->GetBinError(yi),2);
    }
  }
  cout << ysumsig << " " << yerrsig << " " << ysumbg << " " << yerrbg << endl;
  if(ysumbg==0&&ysumsig==0){
    a=0;
    yea=0;
    yerr=3;
  }
  else if(ysumbg==0){
    a=0;
    yea=0;
    yerr=1;
    
  }
  else if(ysumsig==0){
    a=0;
    yea=0;
    yerr=2;
  }
  else{
    a=ysumsig/ysumbg;
    yea=a*sqrt(yerrsig/ysumsig/ysumsig+yerrbg/ysumbg/ysumbg);
    yerr=0;
  }
  cout << a << endl;
  scalea[0]=a;
  scalea[1]=yea;
  scalea[2]=yerr;
  if(yerr) cout << "ZYA1 Error:" << yerr << endl;
  //return scalea;
}
//----------------------------------------------------------------------------------------------------
void ZYAM2D(TH2F *yHistSig, TH2F *yHistBg, Float_t scalea[3], Int_t nMin=10, Int_t nIter=10){
  //for pp nIter=1 might be fine, for heavy-ions where the background has shape it shouldn't

  const Int_t NMin=100;
 
  float sumSig, sumBg;
  float esumSig, esumBg;
  float sumMin, esumMin;
  scalea[0]=1;
  scalea[1]=0;
  float MinArray[NMin][2];
  float MinArraySig[NMin][2];
  float MinArrayBg[NMin][2];
 
  float maxBinVal;
  int maxBin;
  float bin, err;
  float s,b,es,eb;
  for(int i=0;i<nIter;i++){
    for(int q=0;q<nMin;q++){
      MinArray[q][0]=10000;
    }
    for(int x=1;x<=yHistSig->GetNbinsX();x++){
      for(int y=2;y<=(yHistSig->GetNbinsY()-1);y++){
	maxBinVal=-10000;
	for(int j=0;j<nMin;j++){//Find highest bin
	  if(MinArray[j][0]>maxBinVal){
	    maxBinVal=MinArray[j][0];
	    maxBin=j;
	  }
	}
	s=yHistSig->GetBinContent(x,y);
	b=yHistBg->GetBinContent(x,y);
	es=yHistSig->GetBinError(x,y);
	eb=yHistBg->GetBinError(x,y);
	bin=s-scalea[0]*b;
	//float a11=scalea[0];
	//bin2=s-a11*b;
	//cout << "s" << s << " " << "b"  << b << " " << bin << endl;
	//cout << bin << " " << maxBinVal << " " << maxBin << endl;
	if(bin<maxBinVal){//replce highest bin with current if lower
	  MinArray[maxBin][0]=bin;
	  // cout << maxBin << " " << maxBinVal << " " << bin << " " << MinArray[maxBin][0] << endl;
	  //divide by 0 protections
	  if(scalea[0]==0)scalea[0]=1E-10;
	  if(scalea[1]==0)scalea[1]=1E-10;
	  if(es==0)es=1E-10;
	  if(eb==0)eb=1E-10;
	  if(s==0)s=1E-10;
	  if(b==0)b=1E-10;
	  MinArray[maxBin][1]=pow(es,2)+pow(scalea[0]*b,2)*(pow(scalea[1]/scalea[0],2)+pow(eb/b,2));
	  MinArraySig[maxBin][0]=s;
	  MinArraySig[maxBin][1]=es*es;
	  MinArrayBg[maxBin][0]=b;
	  MinArrayBg[maxBin][1]=eb*eb;
	  //cout << s << " " << b << " " << bin  << " " << maxBin << endl;
	}
      }
    }
    sumSig=0, sumBg=0, esumSig=0, esumBg=0, sumMin=0, esumMin=0;
    for(int j=0;j<nMin;j++){
      //cout << MinArray[j][0] << endl;
      if(MinArray[j][0]!=10000&&MinArraySig[j][0]>1E-9&&MinArrayBg[j][0]>1E-9){
	//	cout << MinArraySig[j][0] << endl;
      sumMin+=MinArray[j][0];
      esumMin+=MinArray[j][1];
      sumSig+=MinArraySig[j][0];
      esumSig+=MinArraySig[j][1];
      sumBg+=MinArrayBg[j][0];
      esumBg+=MinArrayBg[j][1];
      }
    }
    if(sumSig==0){sumSig=1E-10; cout << "Warning: Zero sumSig" << endl;}
    if(sumBg==0){sumBg=1E-10; cout << "Warning: Zero sumBg" << endl;}
    scalea[0]=sumSig/sumBg;
    //cout << sumSig << endl;
    if(sumSig==1E-10)scalea[0]=0;
    scalea[1]=scalea[0]*pow(esumSig/sumSig/sumSig+esumBg/sumBg/sumBg,0.5);
    esumMin=pow(esumMin,0.5);
    esumSig=pow(esumSig,0.5);
    esumBg=pow(esumBg,0.5);
    cout << "Iter:  " << i << "   Min=" << sumMin << " +/- " << esumMin << "  a=" << scalea[0] << endl;  
  }
}
//--------------------------------------------------------------------------------------------------
void ZYAM2D2(TH2F *yHistSig, TH2F *yHistBg, float scalea[3], float ZYAMCent=1.,float ZYAMWidth=0.2){
  //yerr=0 no error
  //yerr=1 no mixed event
  //yerr=2 no signal
  //yerr=3 no signal and no mixed
  
  //float ZYAMCent=1.3;
  //float ZYAMWidth=0.2;//window is cent +/- width so its really a 1/2 width of the window
  float a,yea,yerr;
  //static float scalea[3];
  float ysumsig=0,ysumbg=0,yerrsig=0,yerrbg=0;
  float xcent,ycent;
  int xbins=yHistSig->GetNbinsX();
  int ybins=yHistSig->GetNbinsY();
  float yPi=3.1415926535898;
  //cout << ybins << endl;
  //cout << yHistSig->GetSum() << endl;
  //c20=new TCanvas("c20","",800,600);
  //yHistSig->Draw();
  cout << "ZYAMRegion: " << (ZYAMCent-ZYAMWidth) << "-" << (ZYAMCent+ZYAMWidth) << endl;
  for(int xi=1;xi<=xbins;xi++){
   xcent=yHistSig->GetBinCenter(xi);
    if((fabs(fabs(xcent)-ZYAMCent)<ZYAMWidth)||(fabs(fabs(xcent)-(2*yPi-ZYAMCent))<ZYAMWidth)){
    for(int yi=1;yi<=ybins;yi++){
      ysumsig+=yHistSig->GetBinContent(xi,yi);
      yerrsig+=pow(yHistSig->GetBinError(xi,yi),2);
      ysumbg+=yHistBg->GetBinContent(xi,yi);
      yerrbg+=pow(yHistBg->GetBinError(xi,yi),2);
    }
    }
  }
  cout << ysumsig << " " << yerrsig << " " << ysumbg << " " << yerrbg << endl;
  if(ysumbg==0&&ysumsig==0){
    a=0;
    yea=0;
    yerr=3;
  }
  else if(ysumbg==0){
    a=0;
    yea=0;
    yerr=1;
    
  }
  else if(ysumsig==0){
    a=0;
    yea=0;
    yerr=2;
  }
  else{
    a=ysumsig/ysumbg;
    yea=a*sqrt(yerrsig/ysumsig/ysumsig+yerrbg/ysumbg/ysumbg);
    yerr=0;
  }
  cout << a << endl;
  scalea[0]=a;
  scalea[1]=yea;
  scalea[2]=yerr;
  if(yerr) cout << "ZYA1 Error:" << yerr << endl;
  //return scalea;
}
//-------------------------------------------------------------------------------------------------------
void EffCorr(Float_t &yTPt1, Float_t &yTPt2, Float_t &yAPt1, Float_t &yAPt2, Int_t  yCent, char *yFileName, char *yEffFileName, TH1F *yPhiRaw, TH1F *yPhiCorr, TH1F *yPhiEff,  TH1F *yPhiMixRaw, TH1F *yPhiMixCorr, TH1F *yPhiMixEff, TH2F *yPhiEtaRaw, TH2F *yPhiEtaCorr, TH2F *yPhiEtaEff,  TH2F *yPhiEtaMixRaw, TH2F *yPhiEtaMixCorr, TH2F *yPhiEtaMixEff, Float_t yMPt[3], Int_t yptweighted=0, Int_t yNotDelta=0, Int_t yMethod=1){
  char name[120], name2[105];
  
  float yMPt2[2];
  
  MakeProjections(yTPt1,yTPt2,yAPt1,yAPt2,yCent,yFileName,yPhiRaw,yPhiMixRaw,yPhiEtaRaw,yPhiEtaMixRaw,yMPt,yptweighted,0,yNotDelta);
  
  sprintf(name,"yPhiRaw_%2.2fPT%2.2f_%2.2fpt%2.2f_%d",yTPt1,yTPt2,yAPt1,yAPt2,yCent);
  yPhiRaw->SetName(name);
  
  sprintf(name,"yPhiMixRaw_%2.2fPT%2.2f_%2.2fpt%2.2f_%d",yTPt1,yTPt2,yAPt1,yAPt2,yCent);
  yPhiMixRaw->SetName(name);
  
  sprintf(name,"yPhiEtaRaw_%2.2fPT%2.2f_%2.2fpt%2.2f_%d",yTPt1,yTPt2,yAPt1,yAPt2,yCent);
  yPhiEtaRaw->SetName(name);
  
  sprintf(name,"yPhiEtaMixRaw_%2.2fPT%2.2f_%2.2fpt%2.2f_%d",yTPt1,yTPt2,yAPt1,yAPt2,yCent);
  yPhiEtaMixRaw->SetName(name);
  
  
  //Projections from MC (from eff file)
  TH1F *yPhiMC=new TH1F("yPhiMC","",1,0,1);
  TH1F *yPhiMixMC=new TH1F("yPhiMixMC","",1,0,1);
  TH2F *yPhiEtaMC=new TH2F("yPhiEtaMC","",1,0,1,1,0,1);
  TH2F *yPhiEtaMixMC=new TH2F("yPhiEtaMixMC","",1,0,1,1,0,1);
  MakeProjections(yTPt1,yTPt2,yAPt1,yAPt2,yCent,yEffFileName,yPhiMC,yPhiMixMC,yPhiEtaMC,yPhiEtaMixMC,yMPt2,yptweighted,1,yNotDelta);
  sprintf(name,"yPhiMC_%2.2fPT%2.2f_%2.2fpt%2.2f_%d",yTPt1,yTPt2,yAPt1,yAPt2,yCent);
  yPhiMC->SetName(name);
  sprintf(name,"yPhiMixMC_%2.2fPT%2.2f_%2.2fpt%2.2f_%d",yTPt1,yTPt2,yAPt1,yAPt2,yCent);
  yPhiMixMC->SetName(name);
  sprintf(name,"yPhiEtaMC_%2.2fPT%2.2f_%2.2fpt%2.2f_%d",yTPt1,yTPt2,yAPt1,yAPt2,yCent);
  yPhiEtaMC->SetName(name);
  sprintf(name,"yPhiEtaMixMC_%2.2fPT%2.2f_%2.2fpt%2.2f_%d",yTPt1,yTPt2,yAPt1,yAPt2,yCent);
  yPhiEtaMixMC->SetName(name);
  
  //Efficiency Histograms
  MakeProjections(yTPt1,yTPt2,yAPt1,yAPt2,yCent,yEffFileName,yPhiEff,yPhiMixEff,yPhiEtaEff,yPhiEtaMixEff,yMPt2,yptweighted,0,yNotDelta);
  sprintf(name,"yPhiEff_%2.2fPT%2.2f_%2.2fpt%2.2f_%d",yTPt1,yTPt2,yAPt1,yAPt2,yCent);
  yPhiEff->SetName(name);
  sprintf(name2,"Efficiency %s",yPhiEff->GetTitle());
  yPhiEff->SetTitle(name2);
  
  sprintf(name,"yPhiMixEff_%2.2fPT%2.2f_%2.2fpt%2.2f_%d",yTPt1,yTPt2,yAPt1,yAPt2,yCent);
  yPhiMixEff->SetName(name);
  sprintf(name2,"Efficiency %s",yPhiMixEff->GetTitle());
  yPhiMixEff->SetTitle(name2);
  
  sprintf(name,"yPhiEtaEff_%2.2fPT%2.2f_%2.2fpt%2.2f_%d",yTPt1,yTPt2,yAPt1,yAPt2,yCent);
  yPhiEtaEff->SetName(name);
  sprintf(name2,"Efficiency %s",yPhiEtaEff->GetTitle());
  yPhiEtaEff->SetTitle(name2);
  
  sprintf(name,"yPhiEtaMixEff_%2.2fPT%2.2f_%2.2fpt%2.2f_%d",yTPt1,yTPt2,yAPt1,yAPt2,yCent);
  yPhiEtaMixEff->SetName(name);
  sprintf(name2,"Efficiency %s",yPhiEtaMixEff->GetTitle());
  yPhiEtaMixEff->SetTitle(name2);
  
  
  //Calculate Eff
  yPhiEff->Divide(yPhiMC);
  yPhiMixEff->Divide(yPhiMixMC);
  yPhiEtaEff->Divide(yPhiEtaMC);
  yPhiEtaMixEff->Divide(yPhiEtaMixMC);
  
  // if(yMethod==0){
  // yPhiEff
  
  //Corrected Plots
  *yPhiCorr=(TH1F*)yPhiRaw->Clone();
  sprintf(name,"yPhiCorr_%2.2fPT%2.2f_%2.2fpt%2.2f_%d",yTPt1,yTPt2,yAPt1,yAPt2,yCent);
  yPhiCorr->SetName(name);
  yPhiCorr->Divide(yPhiEff);
  
  *yPhiMixCorr=(TH1F*)yPhiMixRaw->Clone();
  sprintf(name,"yPhiMixCorr_%2.2fPT%2.2f_%2.2fpt%2.2f_%d",yTPt1,yTPt2,yAPt1,yAPt2,yCent);
  yPhiMixCorr->SetName(name);
  yPhiMixCorr->Divide(yPhiMixEff);
  
  *yPhiEtaCorr=(TH2F*)yPhiEtaRaw->Clone();
  sprintf(name,"yPhiEtaCorr_%2.2fPT%2.2f_%2.2fpt%2.2f_%d",yTPt1,yTPt2,yAPt1,yAPt2,yCent);
  yPhiEtaCorr->SetName(name);
  yPhiEtaCorr->Divide(yPhiEtaEff);
  
  *yPhiEtaMixCorr=(TH2F*)yPhiEtaMixRaw->Clone();
  sprintf(name,"yPhiMixCorr_%2.2fPT%2.2f_%2.2fpt%2.2f_%d",yTPt1,yTPt2,yAPt1,yAPt2,yCent);
  yPhiEtaMixCorr->SetName(name);
  yPhiEtaMixCorr->Divide(yPhiEtaMixEff);
  
  //Change some titles
  sprintf(name2,"Uncorrected %s",yPhiRaw->GetTitle());
  yPhiRaw->SetTitle(name2);
  sprintf(name2,"Uncorrected %s",yPhiMixRaw->GetTitle());
  yPhiMixRaw->SetTitle(name2);
  sprintf(name2,"Uncorrected %s",yPhiEtaRaw->GetTitle());
  yPhiEtaRaw->SetTitle(name2);
  sprintf(name2,"Uncorrected %s",yPhiEtaMixRaw->GetTitle());
  yPhiEtaMixRaw->SetTitle(name2);
  
  //Geometry Correction for the eta-phi plots
  if(!yNotDelta){
    int xbins=yPhiEtaCorr->GetNbinsX();
    int ybins=yPhiEtaCorr->GetNbinsY();
    float corr;
    float center;
    float scale=0;
    float sumy;
    //uses the mc for the geomery correction
    for(int yx=1;yx<=xbins;yx++){
      scale+=yPhiEtaMixMC->GetBinContent(yx,ybins/2);
      scale+=yPhiEtaMixMC->GetBinContent(yx,ybins/2+1);
    }
    scale/=2;
    for(int yy=1;yy<=ybins;yy++){
      sumy=0;
      for(int yx=1;yx<=xbins;yx++){
	sumy+=yPhiEtaMixMC->GetBinContent(yx,yy);
      }
      if(sumy==0)sumy=0.00001;
      corr=scale/sumy;
      for(int yx=1;yx<=xbins;yx++){
	yPhiEtaCorr->SetBinContent(yx,yy,corr*yPhiEtaCorr->GetBinContent(yx,yy));
	yPhiEtaCorr->SetBinError(yx,yy,corr*yPhiEtaCorr->GetBinError(yx,yy));
	yPhiEtaMixCorr->SetBinContent(yx,yy,corr*yPhiEtaMixCorr->GetBinContent(yx,yy));
	yPhiEtaMixCorr->SetBinError(yx,yy,corr*yPhiEtaMixCorr->GetBinError(yx,yy));
      }
    }
  }
  /*
  //uses equation for the geometry correct, must be changed if trigger or associtated eta cuts change
  TAxis *yAxis=yPhiEtaCorr->GetYaxis();
  for(int yx=1;yx<=xbins;yx++){
  for(int yy=1;yy<=xbins;yy++){
  center=yAxis->GetBinCenter(yy);
  if(center<0)corr=1/(1+center/1.8);
  else corr=1/(1-center/1.8);
  yPhiEtaCorr->SetBinContent(yx,yy,corr*yPhiEtaCorr->GetBinContent(yx,yy));
  yPhiEtaCorr->SetBinError(yx,yy,corr*yPhiEtaCorr->GetBinError(yx,yy));
  yPhiEtaMixCorr->SetBinContent(yx,yy,corr*yPhiEtaMixCorr->GetBinContent(yx,yy));
  yPhiEtaMixCorr->SetBinError(yx,yy,corr*yPhiEtaMixCorr->GetBinError(yx,yy));
  }
  }
  */
}
//----------------------------------------------------------------------------------------------------------
void EffCorr2(Float_t yTPt1, Float_t yTPt2, Float_t yAPt1, Float_t yAPt2, Int_t yCent, TH1F *yPhiEff, TH1F *yPhiMC, TH1F *yPhiMixEff, TH1F *yPhiMixMC, TH1F *yEtaNEff, TH1F *yEtaNMC, TH1F *yEtaNMixEff, TH1F *yEtaNMixMC, TH1F *yEtaAEff, TH1F *yEtaAMC, TH1F *yEtaAMixEff, TH1F *yEtaAMixMC, TH2F *yPhiEtaEff,  TH2F *yPhiEtaMC, TH2F *yPhiEtaMixEff, TH2F *yPhiEtaMixMC, Int_t yMethod=1){//MovingMax is special for yMethod==4
  char effname[120], effname2[105];
  if(yMethod==0){
    for(int i=1;i<=yPhiEff->GetNbinsX();i++){
      yPhiEff->SetBinContent(i,1);
      yPhiEff->SetBinError(i,0);
      yPhiMixEff->SetBinContent(i,1);
      yPhiMixEff->SetBinError(i,0);
    }
    for(int i=1;i<=yEtaNEff->GetNbinsX();i++){
      yEtaNEff->SetBinContent(i,1);
      yEtaNEff->SetBinError(i,0);
      yEtaAEff->SetBinContent(i,1);
      yEtaAEff->SetBinError(i,0);
      yEtaNMixEff->SetBinContent(i,1);
      yEtaNMixEff->SetBinError(i,0);
      yEtaAMixEff->SetBinContent(i,1);
      yEtaAMixEff->SetBinError(i,0);
    }
    for(int i=1;i<=yPhiEtaEff->GetXaxis()->GetNbins();i++){
      for(int j=1;j<=yPhiEtaEff->GetYaxis()->GetNbins();j++){
	yPhiEtaEff->SetBinContent(i,j,1);
	yPhiEtaEff->SetBinError(i,j,0);
	yPhiEtaMixEff->SetBinContent(i,j,1);
	yPhiEtaMixEff->SetBinError(i,j,0);
      }
    }
  }//yMethod==0
  else{
    //Calculate Eff (Method 1)
    yPhiEff->Divide(yPhiMC);
    yPhiMixEff->Divide(yPhiMixMC);
    yEtaNEff->Divide(yEtaNMC);
    yEtaNMixEff->Divide(yEtaNMixMC);
    yEtaAEff->Divide(yEtaAMC);
    yEtaAMixEff->Divide(yEtaAMixMC);
    yPhiEtaEff->Divide(yPhiEtaMC);
    yPhiEtaMixEff->Divide(yPhiEtaMixMC);
    
    if(yMethod==2){//Use mixed event efficiencys for triggered events
      /*
	yPhiEff=(TH1F*)yPhiMixEff->Clone();
	yPhiEff->SetName("yPhiEff");
      yEtaNEff=(TH1F*)yEtaNMixEff->Clone();
      yEtaNEff->SetName("yEtaNEff");
      yEtaAEff=(TH1F*)yEtaAMixEff->Clone();
      yEtaAEff->SetName("yEtaAEff");
      yPhiEtaEff=(TH1F*)yPhiEtaMixEff->Clone();
      yPhiEtaEff->SetName("yPhiEtaEff");
      */
      for(int i=1;i<=yPhiEff->GetNbinsX();i++){
	yPhiEff->SetBinContent(i,yPhiMixEff->GetBinContent(i));
	yPhiEff->SetBinError(i,yPhiMixEff->GetBinError(i));
      }
      for(int i=1;i<=yEtaNEff->GetNbinsX();i++){
	yEtaNEff->SetBinContent(i,yEtaNMixEff->GetBinContent(i));
	yEtaNEff->SetBinError(i,yEtaNMixEff->GetBinError(i));
	yEtaAEff->SetBinContent(i,yEtaAMixEff->GetBinContent(i));
	yEtaAEff->SetBinError(i,yEtaAMixEff->GetBinError(i));
      }
      for(int i=1;i<=yPhiEtaEff->GetXaxis()->GetNbins();i++){
	for(int j=1;j<=yPhiEtaEff->GetYaxis()->GetNbins();j++){
	  yPhiEtaEff->SetBinContent(i,j,yPhiEtaMixEff->GetBinContent(i,j));
	  yPhiEtaEff->SetBinError(i,j,yPhiEtaMixEff->GetBinError(i,j));
	}
      }
    }
    if(yMethod==3){//Sum one distribution and use it for all
      float eff=0, effE=0, effM=0, effME=0;
      for(int i=1;i<=yPhiEff->GetNbinsX();i++){
	eff+=yPhiEff->GetBinContent(i);
	effE+=pow(yPhiEff->GetBinError(i),2);
	effM+=yPhiMixEff->GetBinContent(i);
	effME+=pow(yPhiMixEff->GetBinError(i),2);
      }
      eff/=yPhiEff->GetNbinsX();
      effM/=yPhiEff->GetNbinsX();
      effE=sqrt(effE)/yPhiEff->GetNbinsX();
      effME=sqrt(effME)/yPhiEff->GetNbinsX();
      cout << "Triggered Event Eff: " << eff << " +/- " << effE << endl;
      cout << "Mixed Event Efficie: " << effM << " +/- " << effME << endl;
      
      for(int i=1;i<=yPhiEff->GetNbinsX();i++){
	yPhiEff->SetBinContent(i,eff);
	yPhiEff->SetBinError(i,effE);
	yPhiMixEff->SetBinContent(i,effM);
	yPhiMixEff->SetBinError(i,effME);
      }
      for(int i=1;i<=yEtaNEff->GetNbinsX();i++){
	yEtaNEff->SetBinContent(i,eff);
	yEtaNEff->SetBinError(i,effE);
	yEtaNMixEff->SetBinContent(i,effM);
	yEtaNMixEff->SetBinError(i,effME);
	yEtaAEff->SetBinContent(i,eff);
	yEtaAEff->SetBinError(i,effE);
	yEtaAMixEff->SetBinContent(i,effM);
	yEtaAMixEff->SetBinError(i,effME);
      }
      for(int i=1;i<=yPhiEtaEff->GetXaxis()->GetNbins();i++){
	for(int j=1;j<=yPhiEtaEff->GetYaxis()->GetNbins();j++){
	  yPhiEtaEff->SetBinContent(i,j,eff);
	  yPhiEtaEff->SetBinError(i,j,effE);
	  yPhiEtaMixEff->SetBinContent(i,j,effM);
	  yPhiEtaMixEff->SetBinError(i,j,effME);
	}
      }
    }
  }
  
  
  yPhiEff->GetYaxis()->SetTitle("Efficiency+Contamination");
  yPhiMixEff->GetYaxis()->SetTitle("Efficiency+Contamination");
  yEtaNEff->GetYaxis()->SetTitle("Efficiency+Contamination");
  yEtaNMixEff->GetYaxis()->SetTitle("Efficiency+Contamination");
  yEtaAEff->GetYaxis()->SetTitle("Efficiency+Contamination");
  yEtaAMixEff->GetYaxis()->SetTitle("Efficiency+Contamination");
  yPhiEtaEff->GetZaxis()->SetTitle("Efficiency+Contamination");
  yPhiEtaMixEff->GetZaxis()->SetTitle("Efficiency+Contamination");
  sprintf(effname,"Efficiency Triggered %3.1f<p_{T}^{Trig}<%3.1f %2.2f<p_{T}^{Assoc}<%2.2f",yTPt1,yTPt2,yAPt1,yAPt2);
  yPhiEff->SetTitle(effname);
  sprintf(effname,"Efficiency Mixed %3.1f<p_{T}^{Trig}<%3.1f %2.2f<p_{T}^{Assoc}<%2.2f", yTPt1,yTPt2,yAPt1,yAPt2);
  yPhiMixEff->SetTitle(effname);
  
  sprintf(effname,"Near-Side Efficiency Triggered %3.1f<p_{T}^{Trig}<%3.1f %2.2f<p_{T}^{Assoc}<%2.2f",yTPt1,yTPt2,yAPt1,yAPt2);
  yEtaNEff->SetTitle(effname);
  sprintf(effname,"Near-Side Efficiency Mixed %3.1f<p_{T}^{Trig}<%3.1f %2.2f<p_{T}^{Assoc}<%2.2f", yTPt1,yTPt2,yAPt1,yAPt2);
  yEtaNMixEff->SetTitle(effname);
  
  sprintf(effname,"Away-Side Efficiency Triggered %3.1f<p_{T}^{Trig}<%3.1f %2.2f<p_{T}^{Assoc}<%2.2f",yTPt1,yTPt2,yAPt1,yAPt2);
  yEtaAEff->SetTitle(effname);
  sprintf(effname,"Away-Side Efficiency Mixed %3.1f<p_{T}^{Trig}<%3.1f %2.2f<p_{T}^{Assoc}<%2.2f", yTPt1,yTPt2,yAPt1,yAPt2);
  yEtaAMixEff->SetTitle(effname);
  
  sprintf(effname,"Efficiency Triggered %3.1f<p_{T}^{Trig}<%3.1f %2.2f<p_{T}^{Assoc}<%2.2f",yTPt1,yTPt2,yAPt1,yAPt2);
  yPhiEtaEff->SetTitle(effname);
  sprintf(effname,"Efficiency Mixed %3.1f<p_{T}^{Trig}<%3.1f %2.2f<p_{T}^{Assoc}<%2.2f",yTPt1,yTPt2,yAPt1,yAPt2);
  yPhiEtaMixEff->SetTitle(effname);
  
  
  //Corrected Plots
  //if still problems try shifting this to the other code
  // yPhiCorr->Divide(yPhiEff);
  /*
  //Change some titles
  sprintf(effname2,"Uncorrected %s",yPhiRaw->GetTitle());
  yPhiRaw->SetTitle(effname2);
  sprintf(effname2,"Uncorrected %s",yPhiMixRaw->GetTitle());
  yPhiMixRaw->SetTitle(effname2);
  sprintf(effname2,"Uncorrected %s",yPhiEtaRaw->GetTitle());
  yPhiEtaRaw->SetTitle(effname2);
  sprintf(effname2,"Uncorrected %s",yPhiEtaMixRaw->GetTitle());
  yPhiEtaMixRaw->SetTitle(effname2);
  */
}

//Efficiency Fits-----------------------------------------------------------------------
void EffFit(Float_t yAPt1,Float_t yAPt2,Int_t Cent,TList *effList, TH1F *yPhiEff, TH1F *yPhiMixEff, TH1F *yEtaNEff, TH1F *yEtaNMixEff, TH1F* yEtaAEff, TH1F *yEtaAMixEff, TH2F *yPhiEtaEff, TH2F *yPhiEtaMixEff, Int_t LSign=0, Int_t VariablePt=0){

  const int xnpt=12;
  //float xptbins[(xnpt+1)]={2.5,3,4,6,8,10,15,20,30,40,50,75,100};
  float xptbins[(xnpt+1)]={2,2.5,3,4,5,6,8,10,15,20,30,40,50};
  
  int maxPtTrig=10;//we don't want to go beyond our resolution/statistics
  //if(yAPt1>0.5)maxPtTrig=15;
  if(yAPt1>1)maxPtTrig=8;
  if(yAPt1>1.5)maxPtTrig=6;

  int minPtTrig=yAPt1;
  //set up trigger array
  int size1=0;
  for(int i=0;i<xnpt;i++)if(xptbins[i]>(yAPt1+0.0001)&&xptbins[i]<(maxPtTrig-0.0001))size1++;
  const int NTPt=size1;
  float yPi=3.1415962;
  Float_t X[NTPt];
  Float_t T0[2][NTPt];
  Float_t T1[2][NTPt];
  Float_t T2[2][NTPt];
  Float_t T3[2][NTPt];
  Float_t T4[2][NTPt];
  Float_t M0[2][NTPt];
  Float_t NT0[2][NTPt];
  Float_t NT1[2][NTPt];
  Float_t NT2[2][NTPt];
  Float_t NT3[2][NTPt];
  Float_t NT4[2][NTPt];
  Float_t NM0[2][NTPt];
  Float_t AT0[2][NTPt];
  Float_t AM0[2][NTPt];
  
  TH1F *hPhiEff=new TH1F("hPhiEff","",1,0,1);
  TH1F *hPhiMC=new TH1F("hPhiMC","",1,0,1);
  TH1F *hPhiMixEff=new TH1F("hPhiMixEff","",1,0,1);
  TH1F *hPhiMixMC=new TH1F("hPhiMixMC","",1,0,1);
  
  TH1F *hEtaNEff=new TH1F("hEtaNEff","",1,0,1);
  TH1F *hEtaNMC=new TH1F("hEtaNMC","",1,0,1);
  TH1F *hEtaNMixEff=new TH1F("hEtaNMixEff","",1,0,1);
  TH1F *hEtaNMixMC=new TH1F("hEtaNMixMC","",1,0,1);
  
  TH1F *hEtaAEff=new TH1F("hEtaAEff","",1,0,1);
  TH1F *hEtaAMC=new TH1F("hEtaAMC","",1,0,1);
  TH1F *hEtaAMixEff=new TH1F("hEtaAMixEff","",1,0,1);
  TH1F *hEtaAMixMC=new TH1F("hEtaAMixMC","",1,0,1);
  
  TH2F *hPhiEtaEff=new TH2F("hPhiEtaEff","",1,0,1,1,0,1);
  TH2F *hPhiEtaMC=new TH2F("hPhiEtaMC","",1,0,1,1,0,1);
  TH2F *hPhiEtaMixEff=new TH2F("hPhiEtaMixEff","",1,0,1,1,0,1);
  TH2F *hPhiEtaMixMC=new TH2F("hPhiEtaMixMC","",1,0,1,1,0,1);
  
  TF1 *fit1=new TF1("fit1","[0]+[1]/[2]*exp(-0.5*pow(x/[2],2))+[3]/[4]*exp(-0.5*pow((x-3.1415962)/[4],2))",-1.5,6);
  TF1 *fit2=new TF1("fit2","[0]",-2,6);
 TF1 *fit3=new TF1("fit3","[0]+[1]/[2]*exp(-0.5*pow(x/[2],2))",-2,6);
  fit1->SetParameters(1,0.1,0.1,0.1,0.1);
  fit2->SetParameter(0,1);
  fit3->SetParameters(1,0.1,0.1);
  fit1->SetParLimits(0,0,1000);
  fit1->SetParLimits(1,0,10);
  fit1->SetParLimits(2,0,10);
  fit1->SetParLimits(3,0,10);
  fit1->SetParLimits(4,0,10);
  fit3->SetParLimits(0,0,1000);
  fit3->SetParLimits(1,0,10);
  fit3->SetParLimits(2,0,10);

  float MPt[4];
  float TPt1,TPt2,APt1,APt2;
  for(int i=0;i<NTPt;i++){
    TPt1=xptbins[i];
    TPt2=xptbins[i+1];
    APt1=yAPt1;
    APt2=yAPt2;
    if(VariablePt)APt2=maxPtTrig;
    
    MakeProjections(TPt1,TPt2,APt1,APt2,Cent,effList,hPhiEff,hPhiMixEff,hEtaNEff,hEtaNMixEff,hEtaAEff,hEtaAMixEff,hPhiEtaEff,hPhiEtaMixEff,MPt,0,0,0,LSign);
    MakeProjections(TPt1,TPt2,APt1,APt2,Cent,effList,hPhiMC,hPhiMixMC,hEtaNMC,hEtaNMixMC,hEtaAMC,hEtaAMixMC,hPhiEtaMC,hPhiEtaMixMC,MPt,0,1,0,LSign);
    // EffCorr2(TPt1,TPt2,APt1,APt2,Cent,hPhiEff,hPhiMC,hPhiMixEff,hPhiMixMC,hEtaNEff,hEtaNMC,hEtaNMixEff,hEtaNMixMC,hEtaAEff,hEtaAMC,hEtaAMixEff,hEtaAMixMC,hPhiEtaEff,hPhiEtaMC,hPhiEtaMixEff,hPhiEtaMixMC,1);
    EffCorr2(TPt1,TPt2,APt1,APt2,Cent,hPhiEff,hPhiMC,hPhiMixEff,hPhiMixMC,hEtaNEff,hEtaNMC,hEtaNMixEff,hEtaNMixMC,hEtaAEff,hEtaAMC,hEtaAMixEff,hEtaAMixMC,hPhiEtaEff,hPhiEtaMC,hPhiEtaMixEff,hPhiEtaMixMC,1);
    X[i]=(TPt1+TPt2)*0.5;
    
    hPhiEff->Fit("fit1");
    T0[0][i]=fit1->GetParameter(0);
    T0[1][i]=fit1->GetParError(0);
    T1[0][i]=fit1->GetParameter(1);
    T1[1][i]=fit1->GetParError(1);
    T2[0][i]=fit1->GetParameter(2);
    T2[1][i]=fit1->GetParError(2);
    T3[0][i]=fit1->GetParameter(3);
    T3[1][i]=fit1->GetParError(3);
    T4[0][i]=fit1->GetParameter(4);
    T4[1][i]=fit1->GetParError(4);

    hPhiMixEff->Fit("fit2");
    M0[0][i]=fit2->GetParameter(0);
    M0[1][i]=fit2->GetParError(0);
    
    hEtaNEff->Fit("fit3");
    NT0[0][i]=fit3->GetParameter(0);
    NT0[1][i]=fit3->GetParError(0);
    NT1[0][i]=fit3->GetParameter(1);
    NT1[1][i]=fit3->GetParError(1);
    NT2[0][i]=fit3->GetParameter(2);
    NT2[1][i]=fit3->GetParError(2);
 
    
    hEtaNMixEff->Fit("fit2");
    NM0[0][i]=fit2->GetParameter(0);
    NM0[1][i]=fit2->GetParError(0);
    
    hEtaAEff->Fit("fit2");
    AT0[0][i]=fit2->GetParameter(0);
    AT0[1][i]=fit2->GetParError(0);
    
    hEtaNMixEff->Fit("fit2");
    AM0[0][i]=fit2->GetParameter(0);
    AM0[1][i]=fit2->GetParError(0);
  }
  
  gT0=new TGraphErrors(NTPt,X,T0[0],0,T0[1]);
  gT1=new TGraphErrors(NTPt,X,T1[0],0,T1[1]);
  gT2=new TGraphErrors(NTPt,X,T2[0],0,T2[1]);
  gT3=new TGraphErrors(NTPt,X,T3[0],0,T3[1]);
  gT4=new TGraphErrors(NTPt,X,T4[0],0,T4[1]);

  gM0=new TGraphErrors(NTPt,X,M0[0],0,M0[1]);
  
  gNT0=new TGraphErrors(NTPt,X,NT0[0],0,NT0[1]);
  gNT1=new TGraphErrors(NTPt,X,NT1[0],0,NT1[1]);
  gNT2=new TGraphErrors(NTPt,X,NT2[0],0,NT2[1]);

  gNM0=new TGraphErrors(NTPt,X,NM0[0],0,NM0[1]);

  gAT0=new TGraphErrors(NTPt,X,AT0[0],0,AT0[1]);
  gAM0=new TGraphErrors(NTPt,X,AM0[0],0,AM0[1]);
  
  float pT0[2],pT1[2],pT2[2],pT3[2],pT4[2];
  float pM0[2];
  float pNT0[2],pNT1[2],pNT2[2],pNT3[2],pNT4[2];
  float pNM0[2];
  float pAT0[2];
  float pAM0[2];
  
  gT0->Fit("fit2");
  pT0[0]=fit2->GetParameter(0);
  pT0[1]=fit2->GetParError(0);
  gT1->Fit("fit2");
  pT1[0]=fit2->GetParameter(0);
  pT1[1]=fit2->GetParError(0);
  gT2->Fit("fit2");
  pT2[0]=fit2->GetParameter(0);
  pT2[1]=fit2->GetParError(0);
  gT3->Fit("fit2");
  pT3[0]=fit2->GetParameter(0);
  pT3[1]=fit2->GetParError(0);
  gT4->Fit("fit2");
  pT4[0]=fit2->GetParameter(0);
  pT4[1]=fit2->GetParError(0);
  
  gNT0->Fit("fit2");
  pNT0[0]=fit2->GetParameter(0);
  pNT0[1]=fit2->GetParError(0);
  gNT1->Fit("fit2");
  pNT1[0]=fit2->GetParameter(0);
  pNT1[1]=fit2->GetParError(0);
  gNT2->Fit("fit2");
  pNT2[0]=fit2->GetParameter(0);
  pNT2[1]=fit2->GetParError(0);
  
  gM0->Fit("fit2");
  pM0[0]=fit2->GetParameter(0);
  pM0[1]=fit2->GetParError(0);
  
  gNM0->Fit("fit2");
  pNM0[0]=fit2->GetParameter(0);
  pNM0[1]=fit2->GetParError(0);
  
  gAM0->Fit("fit2");
  pAM0[0]=fit2->GetParameter(0);
  pAM0[1]=fit2->GetParError(0);
  
  gAT0->Fit("fit2");
  pAT0[0]=fit2->GetParameter(0);
  pAT0[1]=fit2->GetParError(0);
  
  float eff,gaus,err,cent;
  float gausA,errA;
  for(int x=1;x<=yPhiEff->GetNbinsX();x++){
    cent=yPhiEff->GetBinCenter(x);
    if(pT2[0]==0)cout << "Error pT2[0]" << endl;
    gaus=pT1[0]/pT2[0]*exp(-0.5*pow(cent/pT2[0],2));
    gausA=pT3[0]/pT4[0]*exp(-0.5*pow((cent-yPi)/pT4[0],2));
    eff=gaus+gausA+pT0[0];
    if(pT1[0]==0) cout << "Error pT1[0]" << endl;
    if(gaus==0)gaus+=1E-10;//divide by 0 protection
    if(gausA==0)gausA+=1E-10;
    err=pow(pow(pT0[1],2)+pow(pT1[1]*gaus/pT1[0],2)+pow(pT2[1]*gaus/pT2[0]*(pow(cent/pT2[0],2)-1),2)+pow(pT3[1]*gausA/pT3[0],2)+pow(pT4[1]*gausA/pT4[0]*(pow((cent-yPi)/pT4[0],2)-1),2),0.5);
    yPhiEff->SetBinContent(x,eff);
    yPhiEff->SetBinError(x,err);
    
    yPhiMixEff->SetBinContent(x,pM0[0]);
    yPhiMixEff->SetBinError(x,pM0[1]);
  }
  for(int x=1;x<=yEtaNEff->GetNbinsX();x++){
    cent=yEtaNEff->GetBinCenter(x);
    if(pNT2[0]==0)cout << "Error pNT2[0]" << endl;
    gaus=pNT1[0]/pNT2[0]*exp(-0.5*pow(cent/pNT2[0],2));
    eff=gaus+pNT0[0];
    if(pNT1[0]==0) cout << "Error pNT1[0]" << endl;
    err=pow(pow(pNT0[1],2)+pow(pNT1[1]*gaus/pNT1[0],2)+pow(pNT2[1]*gaus/pNT2[0]*(pow(cent/pNT2[0],2)-1),2),0.5);
    yEtaNEff->SetBinContent(x,eff);
    yEtaNEff->SetBinError(x,err);

    yEtaNMixEff->SetBinContent(x,pNM0[0]);
    yEtaNMixEff->SetBinError(x,pNM0[1]);

    yEtaAEff->SetBinContent(x,pAT0[0]);
    yEtaAEff->SetBinError(x,pAT0[1]);
    
    yEtaAMixEff->SetBinContent(x,pAM0[0]);
    yEtaAMixEff->SetBinError(x,pAM0[1]);
  }

  float gaus2,eff2,err2,cent2;
  float eff3,err3;
  for(int x=1;x<=yPhiEtaEff->GetXaxis()->GetNbins();x++){
    cent=yPhiEtaEff->GetXaxis()->GetBinCenter(x);
    for(int y=1;y<=yPhiEtaEff->GetYaxis()->GetNbins();y++){
      if(fabs(cent)<1.5||fabs(cent+2*yPi)<1.5||fabs(cent-2*yPi)<1.5){
      gaus=pT1[0]/pT2[0]*exp(-0.5*pow(cent/pT2[0],2));
      eff=gaus;
      if(eff==0)eff+=1E-10;//divide by 0 protection
      err=pow(pow(pT1[1]*gaus/pT1[0],2)+pow(pT2[1]*gaus/pT2[0]*(pow(cent/pT2[0],2)-1),2),0.5); 
      cent2=yPhiEtaEff->GetYaxis()->GetBinCenter(y);
      gaus2=pNT1[0]/pNT2[0]*exp(-0.5*pow(cent2/pNT2[0],2));
      eff2=gaus2;
      if(eff2==0)eff2+=1E-10;//divide by 0 protection
      err2=pow(pow(pNT1[1]*gaus2/pNT1[0],2)+pow(pNT2[1]*gaus2/pNT2[0]*(pow(cent2/pNT2[0],2)-1),2),0.5);
      // eff3=pow(eff*eff2,0.5);
      eff3=pow(gaus*gaus2,0.5)+pow((pT0[0])*pNT0[0],0.5);
      // eff=pow(pT0[0]*pNT0[0],0.5);
      err3=pow(gaus*gaus2*(pow(err/eff,2)+pow(err2/eff2,2))+pT0[0]*pNT0[0]*(pow(pT0[1]/pT0[0],2)+pow(pNT0[1]/pNT0[0],2)),0.5);
    
      }
      else{
	gausA=pT3[0]/pT4[0]*exp(-0.5*pow((cent-yPi)/pT4[0],2));
	if(gausA==0)gausA+=1E-10;
	eff3=pow((pT0[0]+gausA)*pAT0[0],0.5);
	//err3=pow(pow(pT0[1]/pT0[0],2)+pow(pAT0[1]/pAT0[0],2),0.5);
	err3=eff3*pow((pow(pT0[1],2)+pow(pT3[1]*gausA/pT3[0],2)+pow(pT4[1]*gausA/pT4[0]*(pow((cent-yPi)/pT4[0],2)-1),2))/pow(pT0[0]+gausA,2)+pow(pAT0[1]/pAT0[1],2),0.5);
      }
       yPhiEtaEff->SetBinContent(x,y,eff3);
      yPhiEtaEff->SetBinError(x,y,err3);
      
      if(fabs(cent)<1.5){
	eff3=pow(pM0[0]*pNM0[0],0.5);
	err3=pow(pow(pM0[1]/pM0[0],2)+pow(pNM0[1]/pNM0[0],2),0.5);
      }
      else{
	eff3=pow(pM0[0]*pAM0[0],0.5);
	err3=pow(pow(pM0[1]/pM0[0],2)+pow(pAM0[1]/pAM0[0],2),0.5);
      }
      yPhiEtaMixEff->SetBinContent(x,y,eff3);
      yPhiEtaMixEff->SetBinError(x,y,err3);
    }
  }
  }

 //Geometry Correction for the eta-phi plots
 //\-------------------------------------------------------------------
void GeoCorr(TH1F *yEtaNCorr, TH1F *yEtaNMixCorr, TH1F *yEtaNMixMC, TH1F *yEtaACorr, TH1F *yEtaAMixCorr, TH1F *yEtaAMixMC, TH2F *yPhiEtaCorr, TH2F *yPhiEtaMixCorr, TH2F *yPhiEtaMixMC){
  
  int xbins=yEtaNCorr->GetNbinsX();
   
  float corr;
  float center;
  float scale=0,scaleN,scaleA;
  float sumy;
  float escaleN,escaleA, ecorr;
  float con,err;
  scaleN=(yEtaNMix->GetBinContent(xbins/2)+yEtaNMix->GetBinContent(xbins/2+1))/2.;
  escaleN=pow(yEtaNMix->GetBinError(xbins/2),2)+pow(yEtaNMix->GetBinError(xbins/2+1),2)/4.;
  scaleA=(yEtaAMix->GetBinContent(xbins/2)+yEtaAMix->GetBinContent(xbins/2+1))/2.;
  escaleA=pow(yEtaAMix->GetBinError(xbins/2),2)+pow(yEtaAMix->GetBinError(xbins/2+1),2)/4.;
  if(scaleN==0)scaleN=1E-5;
  if(scaleA==0)scaleA=1E-5;
  for(int yx=1;yx<=xbins;yx++){
    con=yEtaNMixMC->GetBinContent(yx);
    if(con==0){con=1E-5;corr=1E-5;}//divide by 0 protection
    else corr=scaleN/con;
    ecorr=corr*corr*(escaleN/scaleN/scaleN+pow(yEtaNMixMC->GetBinError(yx),2)/con/con);
    con=yEtaNCorr->GetBinContent(yx);
    err=pow(yEtaNCorr->GetBinError(yx),2);
    yEtaNCorr->SetBinContent(yx,corr*con);
    if(con==0)con=1E-5;//Divide by 0 protection
    if(corr==0)corr=1E-5;
    yEtaNCorr->SetBinError(yx,corr*con*pow(ecorr/corr/corr+err/con/con,0.5));
    con=yEtaNMixCorr->GetBinContent(yx);
    err=pow(yEtaNMixCorr->GetBinError(yx),2);
    yEtaNMixCorr->SetBinContent(yx,corr*con);
    if(con==0)con=1E-5;
    if(corr==0)corr=1E-5;
    yEtaNMixCorr->SetBinError(yx,corr*con*pow(ecorr/corr/corr+err/con/con,0.5));

    con=yEtaAMixMC->GetBinContent(yx);
    if(con==0){con=1E-5;corr=1E-5;}
    else corr=scaleA/con;
    ecorr=corr*corr*(escaleA/scaleA/scaleA+pow(yEtaAMixMC->GetBinError(yx),2)/con/con);
    con=yEtaACorr->GetBinContent(yx);
    err=pow(yEtaACorr->GetBinError(yx),2);
    yEtaACorr->SetBinContent(yx,corr*con);
    if(con==0)con=1E-5;
    if(corr==0)corr=1E-5;
    yEtaACorr->SetBinError(yx,corr*con*pow(ecorr/corr/corr+err/con/con,0.5));
    con=yEtaAMixCorr->GetBinContent(yx);
    err=pow(yEtaAMixCorr->GetBinError(yx),2);
    yEtaAMixCorr->SetBinContent(yx,corr*con);
    if(con==0)con=1E-5;
    if(corr==0)corr=1E-5;
    yEtaAMixCorr->SetBinError(yx,corr*con*pow(ecorr/corr/corr+err/con/con,0.5));
  }//end eta loop
  
  xbins=yPhiEtaCorr->GetNbinsX();
  int ybins=yPhiEtaCorr->GetNbinsY();
  scale=0;
  //uses the mc for the geomery correction
  for(int yx=1;yx<=xbins;yx++){
    scale+=yPhiEtaMixMC->GetBinContent(yx,ybins/2);
    scale+=yPhiEtaMixMC->GetBinContent(yx,ybins/2+1);
  }
  scale/=2.;
  for(int yy=1;yy<=ybins;yy++){
    sumy=0;
    for(int yx=1;yx<=xbins;yx++){
      sumy+=yPhiEtaMixMC->GetBinContent(yx,yy);
    }
    if(sumy==0)sumy=0.00001;
    corr=scale/sumy;
    for(int yx=1;yx<=xbins;yx++){
      yPhiEtaCorr->SetBinContent(yx,yy,corr*yPhiEtaCorr->GetBinContent(yx,yy));
      yPhiEtaCorr->SetBinError(yx,yy,corr*yPhiEtaCorr->GetBinError(yx,yy));
      yPhiEtaMixCorr->SetBinContent(yx,yy,corr*yPhiEtaMixCorr->GetBinContent(yx,yy));
      yPhiEtaMixCorr->SetBinError(yx,yy,corr*yPhiEtaMixCorr->GetBinError(yx,yy));
    }
  }
}
//-----------------------------------------------------------------------------------------------
void GeoCorr2(TH1F *yEtaNCorr, TH1F *yEtaNMixCorr, TH1F *yEtaACorr, TH1F *yEtaAMixCorr, TH2F *yPhiEtaCorr, TH2F *yPhiEtaMixCorr){
  int nbins=yEtaNCorr->GetNbinsX();
  int nbinsPhi=yPhiEtaCorr->GetNbinsX();
  int nbinsEta=yPhiEtaCorr->GetNbinsY();
  float EtaCut=yEtaNCorr->GetBinCenter(nbins)+yEtaNCorr->GetBinWidth(nbins)/2.;
  float corr;
  float cent;
  for(int i=1;i<=nbins;i++){
    cent=yEtaNCorr->GetBinCenter(i);
    corr=1-fabs(cent)/EtaCut;
    yEtaNCorr->SetBinContent(i,yEtaNCorr->GetBinContent(i)/corr);
    yEtaNCorr->SetBinError(i,yEtaNCorr->GetBinError(i)/corr);
    yEtaNMixCorr->SetBinContent(i,yEtaNMixCorr->GetBinContent(i)/corr);
    yEtaNMixCorr->SetBinError(i,yEtaNMixCorr->GetBinError(i)/corr);
    yEtaACorr->SetBinContent(i,yEtaACorr->GetBinContent(i)/corr);
    yEtaACorr->SetBinError(i,yEtaACorr->GetBinError(i)/corr);
    yEtaAMixCorr->SetBinContent(i,yEtaAMixCorr->GetBinContent(i)/corr);
    yEtaAMixCorr->SetBinError(i,yEtaAMixCorr->GetBinError(i)/corr);
  }
  for(int i=1;i<=nbinsEta;i++){
    cent=yPhiEtaCorr->GetYaxis()->GetBinCenter(i);
    corr=1-fabs(cent)/EtaCut;
    for(int j=1;j<=nbinsPhi;j++){
      yPhiEtaCorr->SetBinContent(j,i,yPhiEtaCorr->GetBinContent(j,i)/corr);
      yPhiEtaCorr->SetBinError(j,i,yPhiEtaCorr->GetBinError(j,i)/corr);
      yPhiEtaMixCorr->SetBinContent(j,i,yPhiEtaMixCorr->GetBinContent(j,i)/corr);
      yPhiEtaMixCorr->SetBinError(j,i,yPhiEtaMixCorr->GetBinError(j,i)/corr);
    }
  }
}
//---------------------------------------------------------------------------------
void Load3Particle(Float_t &xTPt1, Float_t &xTPt2, Float_t &xAPt1, Float_t &xAPt2,Int_t xCent, TList *xList, TH2F *xPhiPhiRaw,TH2F *xPhiPhiSS,TH2F *xPhiPhiMix, TH2F *xEtaEtaRaw, TH2F *xEtaEtaSS, TH2F *xEtaEtaMix,Int_t xMC=0, Int_t xSign=0){
  const int xnAPt=7;
  float xAPt31[xnAPt]={0.5,1.0,1.5,2.0,3,4,1};
  float xAPt32[xnAPt]={1.0,1.5,2.0,3.0,4,5,2};
  const int xnTPt=12;
  float xTPt[(xnTPt+1)]={2,2.5,3,4,5,6,8,10,15,20,30,40,50};//any element in this array should also been in the one 2 lines down
 float xPi=3.1415962;
  int APtBin=-1;
  int TPtBin1=-1;
  int TPtBin2=-1;
  for(int i=0;i<xnAPt;i++){
    if(fabs(xAPt1-xAPt31[i])<0.1&&fabs(xAPt2-xAPt32[i])<0.1){
      xAPt1=xAPt31[i];
      xAPt2=xAPt32[i];
      APtBin=i;
    }
  }
  if(APtBin==-1){
    cout << "Invalid Associated Pt: " << xAPt1 << " " << xAPt2 << endl;
    cout << "Valid values are:" << endl;
    for(int i=0;i<xnAPt;i++){
      cout << "APt1: " << xAPt31[i] << "  APt2: " << xAPt32[i] << endl;
    }
    break;
  }
  for(int i=0;i<xnTPt;i++){
    if(fabs(xTPt1-xTPt[i])<0.1){
     xTPt1=xTPt[i];
     TPtBin1=i;
    }
    if(fabs(xTPt2-xTPt[i+1])<0.1){
      xTPt2=xTPt[i+1];
      TPtBin2=i;
    }
  }
  if(TPtBin1==-1||TPtBin2==-1){
    cout << "Invalid Trigger Pt: " << xTPt1 << " " << xTPt2 << end;
     cout << "Valid values are:" << endl;
    for(int i=0;i<=xnTPt;i++){
      cout <<  xTPt[i] << "  ";
    }
    cout << endl;
    break;
  }
  char xname[100];
  char xtit[200];
 char *cmc1[2]={"","_MC"};
  sprintf(xname,"fHistNTrigger_C%d%s",xCent,cmc1[xMC]);
  TH1F *xNTrig=(TH1F*)xList->FindObject(xname);
  sprintf(xname,"fHistNMix_C%d%s",xCent,cmc1[xMC]);
  TH1F *xNMix=(TH1F*)xList->FindObject(xname);
  int ntriggers=xNTrig->GetBinContent(1);
  int nmix=xNMix->GetBinContent(1);
  // c100=new TCanvas("c100");
  // xNTrig->Draw();
  TH2F *xtemphistP;
  TH2F *xtemphistPSS;
  TH2F *xtemphistPMix;
  TH2F *xtemphistE;
  TH2F *xtemphistESS;
  TH2F *xtemphistEMix;
  //char *cmc1[2]={"","_MC"};
  char *sign1[3]={"","_LS","_ULS"};
  char *sign2[3]={""," LikeSign"," UnlikeSign"};
  int nbins;
  float min,max;
  float conP, conPSS, conPMix, conE, conESS, conEMix;
  float errP, errPSS, errPMix, errE, errESS, errEMix;
  float xntrig=0;
  float xnmix=0;
  

  for(int xi=TPtBin1;xi<=TPtBin2;xi++){//Do for all trigger pt ranges we are adding
    xntrig+=xNTrig->GetBinContent(xi+1);
    //cout << xi << " " << xNTrig->GetBinContent(xi+1) << endl;
    xnmix+=xNMix->GetBinContent(xi+1);
    sprintf(xname,"fHistDeltaPhiPhi_P%dp%d_C%d%s%s",xi,APtBin,xCent,cmc1[xMC],sign1[xSign]);
    xtemphistP=(TH2F*)xList->FindObject(xname);

    sprintf(xname,"fHistDeltaPhiPhiSS_P%dp%d_C%d%s%s",xi,APtBin,xCent,cmc1[xMC],sign1[xSign]);
    xtemphistPSS=(TH2F*)xList->FindObject(xname);

    sprintf(xname,"fHistDeltaPhiPhiMix_P%dp%d_C%d%s%s",xi,APtBin,xCent,cmc1[xMC],sign1[xSign]);
    xtemphistPMix=(TH2F*)xList->FindObject(xname);
   
    sprintf(xname,"fHistDeltaEtaEta_P%dp%d_C%d%s%s",xi,APtBin,xCent,cmc1[xMC],sign1[xSign]);
    xtemphistE=(TH2F*)xList->FindObject(xname);

    sprintf(xname,"fHistDeltaEtaEtaSS_P%dp%d_C%d%s%s",xi,APtBin,xCent,cmc1[xMC],sign1[xSign]);
    xtemphistESS=(TH2F*)xList->FindObject(xname);

    sprintf(xname,"fHistDeltaEtaEtaMix_P%dp%d_C%d%s%s",xi,APtBin,xCent,cmc1[xMC],sign1[xSign]);
    xtemphistEMix=(TH2F*)xList->FindObject(xname);
  
    if(xi==TPtBin1){
      nbins=xtemphistP->GetNbinsX();
      min=xtemphistP->GetBinCenter(1)-xtemphistP->GetBinWidth(1)/2.;
      max=xtemphistP->GetBinCenter(nbins)+xtemphistP->GetBinWidth(nbins)/2.;
      
      sprintf(xtit,"#Delta#phi-#Delta#phi Distribution for  %3.1f<p_{T}^{Trig}<%3.1f %2.2f<p_{T}^{Assoc}<%2.2f%s",xTPt1,xTPt2,xAPt1,xAPt2,sign2[xSign]);
      *xPhiPhiRaw=new TH2F("dPhiPhiRaw",xtit,nbins,min,max,nbins,min,max);
      xPhiPhiRaw->Sumw2();
      xPhiPhiRaw->GetXaxis()->SetTitle("#Delta#phi");
      xPhiPhiRaw->GetYaxis()->SetTitle("#Delta#phi");
      xPhiPhiRaw->GetZaxis()->SetTitle("#frac{1}{N_{Trig}}#frac{d^{2}N_{pairs}}{d#Delta#phid#Delta#phi}");
      SetTitles2D(xPhiPhiRaw);
      
      sprintf(xtit,"Soft-Soft #Delta#phi-#Delta#phi Distribution for  %3.1f<p_{T}^{Trig}<%3.1f %2.2f<p_{T}^{Assoc}<%2.2f%s",xTPt1,xTPt2,xAPt1,xAPt2,sign2[xSign]);
      *xPhiPhiSS=new TH2F("dPhiPhiSS",xtit,nbins,min,max,nbins,min,max);
      xPhiPhiSS->Sumw2();
      xPhiPhiSS->GetXaxis()->SetTitle("#Delta#phi");
      xPhiPhiSS->GetYaxis()->SetTitle("#Delta#phi");
      xPhiPhiSS->GetZaxis()->SetTitle("#frac{1}{N_{Trig}}#frac{d^{2}N_{pairs}}{d#Delta#phid#Delta#phi}");
      SetTitles2D(xPhiPhiSS);

       sprintf(xtit,"Mixed #Delta#phi-#Delta#phi Distribution for  %3.1f<p_{T}^{Trig}<%3.1f %2.2f<p_{T}^{Assoc}<%2.2f%s",xTPt1,xTPt2,xAPt1,xAPt2,sign2[xSign]);
      *xPhiPhiMix=new TH2F("dPhiPhiMix",xtit,nbins,min,max,nbins,min,max);
      xPhiPhiMix->Sumw2();
      xPhiPhiMix->GetXaxis()->SetTitle("#Delta#phi");
      xPhiPhiMix->GetYaxis()->SetTitle("#Delta#phi");
      xPhiPhiMix->GetZaxis()->SetTitle("#frac{1}{N_{Trig}}#frac{d^{2}N_{pairs}}{d#Delta#phid#Delta#phi}");
      SetTitles2D(xPhiPhiMix);
      nbins=xtemphistE->GetNbinsX();
      min=xtemphistE->GetBinCenter(1)-xtemphistE->GetBinWidth(1)/2.;
      max=xtemphistE->GetBinCenter(nbins)+xtemphistE->GetBinWidth(nbins)/2.;
      sprintf(xtit,"#Delta#eta-#Delta#eta Distribution for  %3.1f<p_{T}^{Trig}<%3.1f %2.2f<p_{T}^{Assoc}<%2.2f%s",xTPt1,xTPt2,xAPt1,xAPt2,sign2[xSign]);
      *xEtaEtaRaw=new TH2F("dEtaEtaRaw",xtit,nbins,min,max,nbins,min,max);
      xEtaEtaRaw->Sumw2();
      xEtaEtaRaw->GetXaxis()->SetTitle("#Delta#eta");
      xEtaEtaRaw->GetYaxis()->SetTitle("#Delta#eta");
      xEtaEtaRaw->GetZaxis()->SetTitle("#frac{1}{N_{Trig}}#frac{d^{2}N_{pairs}}{d#Delta#etad#Delta#eta}");
      SetTitles2D(xEtaEtaRaw);
      
       sprintf(xtit,"Soft-Soft #Delta#eta-#Delta#eta Distribution for  %3.1f<p_{T}^{Trig}<%3.1f %2.2f<p_{T}^{Assoc}<%2.2f%s",xTPt1,xTPt2,xAPt1,xAPt2,sign2[xSign]);
       *xEtaEtaSS=new TH2F("dEtaEtaSS",xtit,nbins,min,max,nbins,min,max);
      xEtaEtaSS->Sumw2();
      xEtaEtaSS->GetXaxis()->SetTitle("#Delta#eta");
      xEtaEtaSS->GetYaxis()->SetTitle("#Delta#eta");
      xEtaEtaSS->GetZaxis()->SetTitle("#frac{1}{N_{Trig}}#frac{d^{2}N_{pairs}}{d#Delta#etad#Delta#eta}");
      SetTitles2D(xEtaEtaSS);

       sprintf(xtit,"Mixed #Delta#eta-#Delta#eta Distribution for  %3.1f<p_{T}^{Trig}<%3.1f %2.2f<p_{T}^{Assoc}<%2.2f%s",xTPt1,xTPt2,xAPt1,xAPt2,sign2[xSign]);
      *xEtaEtaMix=new TH2F("dEtaEtaMix",xtit,nbins,min,max,nbins,min,max);
      xEtaEtaMix->Sumw2();
      xEtaEtaMix->GetXaxis()->SetTitle("#Delta#eta");
      xEtaEtaMix->GetYaxis()->SetTitle("#Delta#eta");
      xEtaEtaMix->GetZaxis()->SetTitle("#frac{1}{N_{Trig}}#frac{d^{2}N_{pairs}}{d#Delta#etad#Delta#eta}");
      SetTitles2D(xEtaEtaMix);

    }
    for(int x=1;x<=xtemphistP->GetNbinsX();x++){
      for(int y=1;y<=xtemphistP->GetNbinsY();y++){
	if(xi==TPtBin1){
	  conP=0;
	  errP=0;
	  conPSS=0;
	  errPSS=0;
	  conPMix=0;
	  errPMix=0;
	}
	else{
	  conP=xPhiPhiRaw->GetBinContent(x,y);
	  errP=xPhiPhiRaw->GetBinError(x,y);
	  conPSS=xPhiPhiSS->GetBinContent(x,y);
	  errPSS=xPhiPhiSS->GetBinError(x,y);
	  conPMix=xPhiPhiMix->GetBinContent(x,y);
	  errPMix=xPhiPhiMix->GetBinError(x,y);
	}
	xPhiPhiRaw->SetBinContent(x,y,conP+xtemphistP->GetBinContent(x,y));
	xPhiPhiRaw->SetBinError(x,y,pow(errP*errP+pow(xtemphistP->GetBinError(x,y),2),0.5));
	xPhiPhiSS->SetBinContent(x,y,conPSS+xtemphistPSS->GetBinContent(x,y));
	xPhiPhiSS->SetBinError(x,y,pow(errPSS*errPSS+pow(xtemphistPSS->GetBinError(x,y),2),0.5));
	xPhiPhiMix->SetBinContent(x,y,conPMix+xtemphistPMix->GetBinContent(x,y));
	xPhiPhiMix->SetBinError(x,y,pow(errPMix*errPMix+pow(xtemphistPMix->GetBinError(x,y),2),0.5));
      }
    }
    
    for(int x=1;x<=xtemphistE->GetNbinsX();x++){
      for(int y=1;y<=xtemphistE->GetNbinsY();y++){
	if(xi==TPtBin1){
	  conE=0;
	  errE=0;
	  conESS=0;
	  errESS=0;
	  conEMix=0;
	  errEMix=0;
	}
	else{
	  conE=xEtaEtaRaw->GetBinContent(x,y);
	  errE=xEtaEtaRaw->GetBinError(x,y);
	  conESS=xEtaEtaSS->GetBinContent(x,y);
	  errESS=xEtaEtaSS->GetBinError(x,y);
	  conEMix=xEtaEtaMix->GetBinContent(x,y);
	  errEMix=xEtaEtaMix->GetBinError(x,y);
	}
	xEtaEtaRaw->SetBinContent(x,y,conE+xtemphistE->GetBinContent(x,y));
	xEtaEtaRaw->SetBinError(x,y,pow(errE*errE+pow(xtemphistE->GetBinError(x,y),2),0.5));
	xEtaEtaSS->SetBinContent(x,y,conESS+xtemphistESS->GetBinContent(x,y));
	xEtaEtaSS->SetBinError(x,y,pow(errESS*errESS+pow(xtemphistESS->GetBinError(x,y),2),0.5));
	xEtaEtaMix->SetBinContent(x,y,conEMix+xtemphistEMix->GetBinContent(x,y));
	xEtaEtaMix->SetBinError(x,y,pow(errEMix*errEMix+pow(xtemphistEMix->GetBinError(x,y),2),0.5));
      
      }
    }
  }

//Normalize the histograms
  //cout << xPi << " " << max << " " << xntrig << " " << xnmix << endl;
  float phibins=xPhiPhiRaw->GetNbinsX();
  float etabins=xEtaEtaRaw->GetNbinsX();
  float scalephi=pow(phibins/(2*xPi),2);
  float scaleeta=pow(etabins/(max-min),2);//max still set for eta from making histograms
  xPhiPhiRaw->Scale(scalephi/xntrig);
  xPhiPhiSS->Scale(scalephi/xnmix);
  xPhiPhiMix->Scale(scalephi/(2.*xnmix));
  xEtaEtaRaw->Scale(scaleeta/xntrig);
  xEtaEtaSS->Scale(scaleeta/xnmix);
  xEtaEtaMix->Scale(scaleeta/(2.*xnmix));
}

//------------------------------------------------------------------------------------
void EffCorr3Part(Float_t TPt1, Float_t TPt2, Float_t APt1, Float_t APt2, Int_t Cent, TH2F *yPhiPhiEff, TH2F *yPhiPhiMC, TH2F *yPhiPhiSSEff, TH2F *yPhiPhiSSMC, TH2F *yPhiPhiMixEff, TH2F *yPhiPhiMixMC, TH2F *yEtaEtaEff, TH2F *yEtaEtaMC, TH2F *yEtaEtaSSEff, TH2F *yEtaEtaSSMC, TH2F *yEtaEtaMixEff, TH2F *yEtaEtaMixMC, Int_t yMethod){
  //Right now only putting in for case where efficiency is taken care of before hand.  I will add others if used
  if(yMethod==0){
    int nBinPhi=yPhiPhiEff->GetNbinsX();
    int nBinEta=yEtaEtaEff->GetNbinsX();
    for(int x=1;x<=nBinPhi;x++){
      for(int y=1;y<=nBinPhi;y++){
	yPhiPhiEff->SetBinContent(x,y,1);
	yPhiPhiEff->SetBinError(x,y,0);
	yPhiPhiSSEff->SetBinContent(x,y,1);
	yPhiPhiSSEff->SetBinError(x,y,0);
	yPhiPhiMixEff->SetBinContent(x,y,1);
	yPhiPhiMixEff->SetBinError(x,y,0);
      }
    }
  for(int x=1;x<=nBinEta;x++){
      for(int y=1;y<=nBinEta;y++){
	yEtaEtaEff->SetBinContent(x,y,1);
	yEtaEtaEff->SetBinError(x,y,0);
	yEtaEtaSSEff->SetBinContent(x,y,1);
	yEtaEtaSSEff->SetBinError(x,y,0);
	yEtaEtaMixEff->SetBinContent(x,y,1);
	yEtaEtaMixEff->SetBinError(x,y,0);
      }
    }
  }
  else{
    Printf("Method needs to be inserted into EffCorr3Part");
    break;
  }
  

}

//-------------------------------------------------------------------------------------------------------
void GeoCorr3Part2(TH2F *yEtaEtaCorr, TH2F *yEtaEtaSSCorr, TH2F *yEtaEtaMixCorr, TH2F *yEtaEtaHSCorr){//using equation to correct
  int bin=yEtaEtaCorr->GetNbinsX();
  float centx, centy;
  float corr,corrx,corry,corrz;
  float EtaCut=yEtaEtaCorr->GetBinCenter(bin)+yEtaEtaCorr->GetBinWidth(bin)/2.;
  cout << "EtaCut " << EtaCut << endl;
  for(int x=1;x<=bin;x++){
    centx=yEtaEtaCorr->GetXaxis()->GetBinCenter(x);
    corrx=1-fabs(centx)/EtaCut;
    for(int y=1;y<=bin;y++){
      centy=yEtaEtaCorr->GetYaxis()->GetBinCenter(y);
      corry=1-fabs(centy)/EtaCut;
      corrz=1-fabs(centx-centy)/EtaCut;
      if(fabs(centx-centy)>EtaCut)corrz=0;
      corr=corrz*pow(corrx*corry,1/2.);
      if(corr==0)corr=1;
      corr=1;
      yEtaEtaCorr->SetBinContent(x,y,yEtaEtaCorr->GetBinContent(x,y)/corr);
      yEtaEtaCorr->SetBinError(x,y,yEtaEtaCorr->GetBinError(x,y)/corr);
      yEtaEtaMixCorr->SetBinContent(x,y,yEtaEtaMixCorr->GetBinContent(x,y)/corr);
      yEtaEtaMixCorr->SetBinError(x,y,yEtaEtaMixCorr->GetBinError(x,y)/corr);
      yEtaEtaSSCorr->SetBinContent(x,y,yEtaEtaSSCorr->GetBinContent(x,y)/corr);
      yEtaEtaSSCorr->SetBinError(x,y,yEtaEtaSSCorr->GetBinError(x,y)/corr);
      yEtaEtaHSCorr->SetBinContent(x,y,yEtaEtaHSCorr->GetBinContent(x,y)/corr);
      yEtaEtaHSCorr->SetBinError(x,y,yEtaEtaHSCorr->GetBinError(x,y)/corr);
    }
  }
}
//--------------------------------------------------------------------------------------------------------------------
void ZYAM3(TH1F *yPhi, TH1F *yPhiMix, TH2F *yPhiPhi, TH2F *yPhiPhiSS, TH2F *yPhiPhiMix, Float_t a[3], Float_t b, Int_t nMin=10, Int_t nIter=10){//xxx scale the mixed event to the SS before it comes in
  const Int_t NMin=100;
  
  // float sumSig2, sumMix2, sumSig3, sumSS3, sumMix3;
  //float esumSig2, esumMix2, esumSig3, esumSS3, esumMix3;
  //float sumMin, esumMin;
  float itersize=0.1;
  float oldmin=1000;
  a[0]=1;
  a[1]=0;
  float MinArray[NMin][2];
  float Phi[NMin][2];
  float SS[NMin][2];
  float Mix[NMin][2];
  float PhiX[NMin][2];
  float PhiY[NMin][2];
   float MixX[NMin][2];
  float MixY[NMin][2];
  int nBins2=yPhi->GetNbinsX();
  int nBins3=yPhiPhi->GetNbinsX();
  int ReBin=nBins2/nBins3;
    if(fabs(1.0*nBins2/nBins3-ReBin)>0.01)Printf("Please use a divisor of the 2-particle binning for the 3-particle");

  float maxBinVal;
  int maxBin;
  float bin, err;
  float phi, ss, mix, phiX, mixX, phiY, mixY;
  float ephi, ess, emix, ephiX, emixX, ephiY, emixY;
  //float b1=yPhiPhi->GetSum()/pow(yPhi->GetSum(),2);
  //float b2=yPhiPhiSS->GetSum()/pow(yPhiMix->GetSum(),2);
  // b=b1/b2;
  for(int i=0;i<nIter;i++){
    for(int q=0;q<nMin;q++){
      MinArray[q][0]=10000;
    }
    for(int x=1;x<=yPhiPhi->GetNbinsX();x++){
      phiX=0, ephiX=0, mixX=0, emixX=0;
      for(int j=(ReBin*(x-1)+1);j<ReBin*x;j++){
	phiX+=yPhi->GetBinContent(j);
	ephiX+=pow(yPhi->GetBinError(j),2);
	mixX+=yPhiMix->GetBinContent(j);
	emixX+=pow(yPhiMix->GetBinError(j),2);
      }
      for(int y=1;y<=yPhiPhi->GetNbinsY();y++){
	phiY=0, ephiY=0, mixY=0, emixY=0;
	for(int j=(ReBin*(y-1)+1);j<ReBin*y;j++){
	phiY+=yPhi->GetBinContent(j);
	ephiY+=pow(yPhi->GetBinError(j),2);
	mixY+=yPhiMix->GetBinContent(j);
	emixY+=pow(yPhiMix->GetBinError(j),2);
      }
	maxBinVal=-10000;
	for(int j=0;j<nMin;j++){//Find highest bin
	  if(MinArray[j][0]>maxBinVal){
	    maxBinVal=MinArray[j][0];
	    maxBin=j;
	  }
	}
	phi=yPhiPhi->GetBinContent(x,y);
	ephi=yPhiPhi->GetBinError(x,y);
	ss=yPhiPhiSS->GetBinContent(x,y);
	ess=yPhiPhiSS->GetBinError(x,y);
	mix=yPhiPhiMix->GetBinContent(x,y);
	emix=yPhiPhiMix->GetBinError(x,y);
	//xxx
	bin=phi-a[0]*mixY*(phiX-a[0]*mixX)-a[0]*mixX*(phiY-a[0]*mixY)-a[0]*a[0]*b*ss;
	//cout << bin << " " << maxBinVal << " " << maxBin << endl;
	if(bin<maxBinVal){//replce highest bin with current if lower
	  MinArray[maxBin][0]=bin;
	  //divide by 0 protections
	  if(a[0]==0)a[0]=1E-10;
	  if(a[1]==0)a[1]=1E-10;
	  if(ephi==0)ephi=1E-10;
	  if(ess==0)ess=1E-10;
	  if(emix==0)emix=1E-10;
	  if(phi==0)phi=1E-10;
	  if(ss==0)ss=1E-10;
	  if(mix==0)mix=1E-10;
	  MinArray[maxBin][1]=ephi*ephi+a[0]*mixY*phiX*(pow(emixY/mixY,2)+pow(ephiX/phiX,2))+2*a[0]*a[0]*mixY*mixX*(pow(emixY/mixY,2)+pow(emixX/mixX,2))+a[0]*mixX*phiY*(pow(emixX/mixX,2)+pow(ephiY/phiY,2))+pow(a[0]*a[0]*b*ess,2);
	  Phi[maxBin][0]=phi;
	  SS[maxBin][0]=ss;
	  Mix[maxBin][0]=mix;
	  PhiX[maxBin][0]=phiX;
	  PhiY[maxBin][0]=phiY;
	  MixX[maxBin][0]=MixX;
	  MixY[maxBin][0]=MixY;
	 
	  //cout << s << " " << b << " " << bin  << " " << maxBin << endl;
	}
      }
    }
    //sumSig=0, sumBg=0, esumSig=0, esumBg=0, sumMin=0, esumMin=0;
    float sumPhi=0,sumHS=0,sumSS=0,sumMix=0,sumMixXY=0, sumMin=0, esumMin=0;
    for(int j=0;j<nMin;j++){
      sumMin+=MinArray[j][0];
      esumMin+=MinArray[j][1];
      sumPhi+=Phi[j][0];
      sumHS+=(PhiX[j][0]*MixY[j][0]+PhiY[j][0]*MixX[j][0]);
      sumMix+=mix;
      sumSS+=b*ss;
      sumMixXY+=(2*MixY[j][0]*MixX[j][0]);
    }
    // if(sumSig==0){sumSig=1E-10; cout << "Warning: Zero sumSig" << endl;}
    // if(sumBg==0){sumBg=1E-10; cout << "Warning: Zero sumBg" << endl;}
    float a1,a2;
    // cout << pow(sumHS*sumHS-4*sumPhi*(sumMixXY-sumSS),0.5) << endl;
    a1=(sumHS+pow(sumHS*sumHS-4*sumPhi*(sumMixXY-sumSS),0.5))/(2*sumPhi*(sumMixXY-sumSS));
    a2=(sumHS-pow(sumHS*sumHS-4*sumPhi*(sumMixXY-sumSS),0.5))/(2*sumPhi*(sumMixXY-sumSS));
    if(fabs(oldmin)<fabs(sumMin))itersize/=2;
    oldmin=sumMin;
    if(a1>0&&a2>0){
      if(fabs(a1-1)<fabs(a2-1)){
	a[0]=a1;
      }
      else a[0]=a2;
    }
    else if(a1<0)a[0]=a2;
    else if(a2<0)a[0]=a1;
    else if(sumMin<0) a[0]-=itersize;
    else a[0]+=itersize;

   
  
    cout << "a1: " << a1 << "    a2: " << a2 << endl;
    //scalea[1]=scalea[0]*pow(esumSig/sumSig/sumSig+esumBg/sumBg/sumBg,0.5);
    esumMin=pow(esumMin,0.5);
    //esumSig=pow(esumSig,0.5);
    //esumBg=pow(esumBg,0.5);
    cout << "Iter:  " << i << "   Min=" << sumMin/nMin << " +/- " << esumMin/nMin << "  a=" << a[0] << endl;  
  }
}
  

//----------------------------------------------------------------------------------------------
void Add1D(TH1F *Histo, TH1F *HistAdd, float xscale){
  int nbinsx=Histo->GetNbinsX();
  for(int xi=1;xi<=nbinsx;xi++){
    if(fabs(Histo->GetBinContent(xi)>1E-10)&&fabs(HistAdd->GetBinContent(xi)>1E-10)){//only add if contents in both
      Histo->SetBinContent(xi,Histo->GetBinContent(xi)+xscale*HistAdd->GetBinContent(xi));
      Histo->SetBinError(xi,sqrt(pow(Histo->GetBinError(xi),2)+pow(xscale*HistAdd->GetBinError(xi),2)));
    }
  }
}
      
//----------------------------------------------------------------------------------
void Add2D(TH2F *Histo, TH2F *HistAdd,float xscale){
  int nbinsx=Histo->GetNbinsX();
  int nbinsy=Histo->GetNbinsY();
  //histOut=(TH2F*)Histo->Clone();
  // histOut->SetName("Added Histo");	
  
  for(int xi=1;xi<=nbinsx;xi++){
    for(int yi=1;yi<=nbinsy;yi++){
      //cout << Histo->GetBinContent(xi,yi) << endl;
      if(fabs(Histo->GetBinContent(xi,yi)>1E-10)&&fabs(HistAdd->GetBinContent(xi,yi))>1E-10){
      Histo->SetBinContent(xi,yi,Histo->GetBinContent(xi,yi)+xscale*HistAdd->GetBinContent(xi,yi));
      Histo->SetBinError(xi,yi,sqrt(pow(Histo->GetBinError(xi,yi),2)+pow(xscale*HistAdd->GetBinError(xi,yi),2)));
      }
    }
  }
}
//----------------------------------------------------------------------------------
void DivideMean1D(TH1F *Hist, TH1F *Hist2,float a1, float a2,float ntrig){
    int nbinsx=Hist->GetNbinsX();
    float bin,err,bin2,err2;
    float sigma=(a2-a1)/2;
    for(int xi=1;xi<=nbinsx;xi++){
      bin=Hist->GetBinContent(xi);
      err=Hist->GetBinError(xi);
      bin2=Hist2->GetBinContent(xi);
      err2=Hist2->GetBinError(xi);
      if(bin2==0){
	bin2=1;
	bin=0;
	err2=1;
      }
      Hist->SetBinContent(xi,bin/bin2);
      Hist->SetBinError(xi,sigma/(err2*ntrig*Hist->GetBinWidth(1)));
    }

}
//---------------------------------------------------------------------------------
//Correction factor screws with the statistics
void DivideMean1DCorr(TH1F *Hist, TH1F *Hist2, TH1F *Hist3, float a1, float a2,float ntrig){
    int nbinsx=Hist->GetNbinsX();
    float bin,err,bin2,err2, bin3, err3;
    float sigma=(a2-a1)/2;
    for(int xi=1;xi<=nbinsx;xi++){
      bin=Hist->GetBinContent(xi);
      err=Hist->GetBinError(xi);
      bin2=Hist2->GetBinContent(xi);
      err2=Hist2->GetBinError(xi);
      bin3=Hist3->GetBinContent(xi);
      err3=Hist3->GetBinError(xi);
      if(bin2==0){
	bin2=1;
	bin=0;
	err2=1;
	err3=1;
      }
      Hist->SetBinContent(xi,bin/bin2);
      Hist->SetBinError(xi,sigma/(err3*ntrig*Hist->GetBinWidth(1)));//error should go with uncorrected counts
    }
}

//-----------------------------
//Background subtraction screws with them more
void DivideMean1DBgSub(TH1F *Hist, TH1F *Hist2,TH1F *Hist3,TH1F *Hist4,float a1, float a2,float ntrig, float nmix){
    int nbinsx=Hist->GetNbinsX();
    float bin,err,bin2,err2,bin3,err3,bin4,err4;
    float sigma=(a2-a1);
    float e1,e2;
    for(int xi=1;xi<=nbinsx;xi++){
      bin=Hist->GetBinContent(xi);
      err=Hist->GetBinError(xi);
      bin2=Hist2->GetBinContent(xi);
      err2=Hist2->GetBinError(xi);
      bin3=Hist3->GetBinContent(xi);
      err3=Hist3->GetBinError(xi);
      bin4=Hist4->GetBinContent(xi);
      err4=Hist4->GetBinError(xi);
      if(bin2==0){
	bin2=1;
	bin=0;
	err2=1;
	err3=1;
	err4=1;
      }
      Hist->SetBinContent(xi,bin/bin2);
      cout << sigma << endl;
      e1=pow(sigma/(err3*ntrig*Hist->GetBinWidth(xi)),2);
      e2=pow(sigma/(err4*nmix*Hist->GetBinWidth(xi)),2);
      cout << e1 << endl;
      
      Hist->SetBinError(xi,sqrt(e1));
    }
}
//----------------------------------------------------------------------------------
void DivideMean2D(TH2F *Hista, TH2F *Hista2, float a1, float a2,float ntrig){
  int nbinsx=Hista->GetXaxis()->GetNbins();
  int nbinsy=Hista->GetXaxis()->GetNbins();
    float bin,err,bin2,err2;
    float sigma=(a2-a1)/2;
    for(int xi=1;xi<=nbinsx;xi++){
      for(int yi=1;yi<=nbinsy;yi++){
	bin=Hista->GetBinContent(xi,yi);
	err=Hista->GetBinError(xi,yi);
	bin2=Hista2->GetBinContent(xi,yi);
	err2=Hista2->GetBinError(xi,yi);
	if(bin2==0){
	  bin2=1;
	  bin=0;
	  err2=1;
	}

	Hista->SetBinContent(xi,yi,bin/bin2);
	Hista->SetBinError(xi,yi,sigma/(err2*ntrig*HistGetXaxis()->GetBinWidth(1)*HistGetYaxis()->GetBinWidth(1)));
      }
    }
}
//----------------------------------------------------------------------------------------------------------------
void SetMargins1D(TCanvas *xc){
  xc->SetRightMargin(0.02);
  xc->SetLeftMargin(0.16);
  xc->SetBottomMargin(0.15);
}

void SetMargins1DCyl(TCanvas *xc){
  xc->SetRightMargin(0.1);
  xc->SetLeftMargin(0.1);
  xc->SetTopMargin(0.05);
  xc->SetBottomMargin(0.05);
  xc->SetTheta(90);
  xc->SetPhi(209);//151,209
}

void SetMargins2DSurf(TCanvas *xc){
  xc->SetBottomMargin(0.15);
  xc->SetLeftMargin(0.21);
  xc->SetRightMargin(0.05);
  xc->SetTopMargin(0.05);
}
void SetMargins2D(TCanvas *xc){
  xc->SetBottomMargin(0.15);
  xc->SetLeftMargin(0.12);
  xc->SetRightMargin(0.25);
}
void SetTitles1D(TH1 *xhisto){
  xhisto->GetXaxis()->SetTitleColor(1);
  xhisto->GetXaxis()->SetTitleSize(0.06);
  xhisto->GetYaxis()->SetTitleSize(0.06);
  xhisto->GetXaxis()->SetLabelSize(0.05);
  xhisto->GetYaxis()->SetLabelSize(0.05);
  xhisto->GetYaxis()->SetTitleOffset(1.2);
}
void SetTitles2D(TH1 *xhisto){
  xhisto->GetXaxis()->SetTitleColor(1);
  xhisto->GetXaxis()->SetTitleSize(0.06);
  xhisto->GetYaxis()->SetTitleSize(0.06);
  xhisto->GetZaxis()->SetTitleSize(0.06);
  xhisto->GetXaxis()->SetLabelSize(0.05);
  xhisto->GetYaxis()->SetLabelSize(0.05);
  xhisto->GetZaxis()->SetLabelSize(0.05);
  xhisto->GetZaxis()->SetTitleOffset(1.43);
}

void Style(int i) 
{
  switch (i) {
  case 1:
    gStyle->SetStatColor(kWhite);
    gStyle->SetTitleColor(kWhite);
    gStyle->SetPadColor(kWhite);
    gStyle->SetCanvasColor(kWhite);
    gStyle->SetPadBorderMode(0);
    gStyle->SetPadBorderSize(0);
    gStyle->SetCanvasBorderMode(0);
    gStyle->SetCanvasBorderSize(0);
    gStyle->SetFrameBorderMode(0);
    gStyle->SetFrameBorderSize(1);
    gStyle->SetFrameFillStyle(0);
    gStyle->SetOptStat(0);
    gStyle->SetOptFit(0);
    gStyle->SetPalette(1);
    break;
  case 2:  //paper figure style
    gStyle->SetStatColor(kWhite);
    gStyle->SetTitleColor(kWhite);
    gStyle->SetPadColor(kWhite);
    gStyle->SetCanvasColor(kWhite);
    gStyle->SetPadBorderMode(0);
    gStyle->SetPadBorderSize(0);
    gStyle->SetCanvasBorderMode(0);
    gStyle->SetCanvasBorderSize(0);
    gStyle->SetFrameBorderMode(0);
    gStyle->SetFrameBorderSize(1);
    gStyle->SetFrameFillStyle(0);
    gStyle->SetOptStat(0);
    gStyle->SetOptFit(1);
    gStyle->SetPalette(1);
    break;
  default:
    break;
  }
}
//------------------------------------------------------------------
void keySymbol(Float_t x, Float_t y, const Char_t* tt, 
               Int_t color=1, Int_t marker=1, Float_t tSize=0.04, Float_t Msize=1.0){

  gPad->Update();

  TLatex *t = new TLatex();
  t->SetNDC();
  t->SetTextAlign(12);
  t->SetTextSize(tSize);
  t->SetTextColor(color);
  t->DrawLatex(x+0.025,y,tt);
  
      
  TMarker *l = new TMarker();
  l->SetNDC(kTRUE);
  l->SetMarkerStyle(marker);
  l->SetMarkerColor(color);
  l->SetMarkerSize(Msize);
  l->PaintMarkerNDC(x-0.0025,y);
  l->SetX(x-0.0025);
  l->SetY(y);
  l->Draw();
}
//------------------------------------------------
void keyText(Float_t x, Float_t y, const Char_t* tt, 
	     Int_t color=1,  Float_t tSize=0.04, Float_t tangle=0){
 
  gPad->Update();
  Float_t x1 = gPad->GetFrame()->GetX1();
  Float_t x2 = gPad->GetFrame()->GetX2();
  Float_t dx = x2-x1;
  x = x1 + dx*x;
  Float_t y1 = gPad->GetFrame()->GetY1();
  Float_t y2 = gPad->GetFrame()->GetY2();
  Float_t dy = y2-y1;
  y = y1 + dy*y; 
TLatex *t = new TLatex(x,y,tt);
  t->SetTextAlign(12);
  t->SetTextSize(tSize);
  t->SetTextColor(color);
  t->SetTextAngle(tangle);
  t->Draw();
}
////////////////////////////////////////////////
void rebin1D(TH1 *&temp1D, int rbins){
  int nbinxx1=temp1D->GetNbinsX();
  int nbinxx2=nbinxx1/rbins;
  float widxx=temp1D->GetBinWidth(1);
  float minxx=temp1D->GetBinCenter(1)-widxx/2;
  float maxxx=temp1D->GetBinCenter(nbinxx1)+widxx/2;
  char *titxx=temp1D->GetTitle();
 
  TH1D *temp1D2=new TH1D("temp1D2",titxx,nbinxx2,minxx,maxxx);
  for(int xx1=1;xx1<=nbinxx2;xx1++){
    float conx1=0,errx1=0;
    for(int xx2=1;xx2<=rbins;xx2++){
      conx1+=temp1D->GetBinContent(rbins*(xx1-1)+xx2);
   
      errx1+=pow(temp1D->GetBinError(rbins*(xx1-1)+xx2),2);

    }

    conx1/=rbins;
    errx1=sqrt(errx1)/rbins;
    temp1D2->SetBinContent(xx1,conx1);
    temp1D2->SetBinError(xx1,errx1);
  }
  char *namex=temp1D->GetName();
  char *xtit=temp1D->GetXaxis()->GetTitle();
  char *ytit=temp1D->GetYaxis()->GetTitle();
  int markx=temp1D->GetMarkerStyle();
  int colx=temp1D->GetMarkerColor();
  temp1D=(TH1D*)temp1D2->Clone();
  temp1D->SetName(namex);
  temp1D->GetXaxis()->SetTitle(xtit);
  temp1D->GetYaxis()->SetTitle(ytit);
  temp1D->SetMarkerStyle(markx);
  temp1D->SetLineColor(colx);
  temp1D->SetMarkerColor(colx);
  SetTitles1D(temp1D);
 
}
////////////////////////////////
//Broken need to fix before I use
void rebin2D(TH2D *temp2D,int rbins){
  int nbinxx1=temp2D->GetNbinsX();
  int nbinxx2=nbinxx2/rbins;
  float widxx=temp2D->GetBinWidth(1);
  float minxx=temp2D->GetBinCenter(1)-widxx/2;
  float maxxx=temp2D->GetBinCenter(nbinxx1)+widxx/2;
  char titxx=temp2D->GetTitle();
  TH2D *temp2D2=new TH2D("temp2D2",titxx,nbinxx2,minxx,maxxx,nbinxx2,minxx,maxxx);
  for(int xx1=1;xx1<=nbinxx2;xx1++){
    for(int yy1=1;yy1<=nbinxx2;yy1++){
      float conx1=0,errx1=0;
      for(int xx2=1;xx2<=rbins;xx2++){
	for(int yy2=1;yy2<=rbins;yy2++){
	  conx1+=temp2D->GetBinContent(rbins*(xx1-1)+xx2,rebins*(yy1-1)+yy2);
	  errx1+=pow(temp2D->GetBinError(rbins(xx1-1)+xx2,rebins*(yy1-1)+yy2),2);
	}
      }
      conx1/=pow(rbins,2);
      errx1=sqrt(errx1)/pow(rbins,2);
      temp2D2->SetBinContent(xx1,conx1);
      temp2D2->SetBinError(xx1,errx1);
    }
  }
  return temp2D2;
}
//----------------------------------
void DrawLego1D(TCanvas *&tc, TH1 *&thist){

  //cout << "off" << thist->GetXaxis()->GetLabelOffset() << endl;
  if(thist->GetMinimum()>0)thist->SetMinimum(0);
  thist->GetXaxis()->SetLabelOffset(-0.1);
  tc1=new TPad("tc1","ytit",0,0.0,0.1,1);
  tc2=new TPad("tc2","main",0.1,0,1,1);
  tc1->Draw();
  tc2->Draw();
  tc2->cd();
  tc2->SetTheta(0);
  tc2->SetPhi(0);
  tc2->SetRightMargin(0.02);
  //xc->SetLeftMargin(0.16);
  tc2->SetBottomMargin(0.15);
  thist->Draw("lego2");
  tc1->cd();
  keyText(.45,.65,"#frac{1}{N_{Trig}}#frac{dN}{d#Delta#phi}",1,0.4,90);
  // thist->GetXaxis()->SetLabelOffset(0);
}
//---------------------------------------
void SaveAsText(TH1 *histo, char *filename){
  
  //I should also make it works with TH2
  FILE *fp;
  fp=fopen(filename,"w");
  fprintf(fp,"Bin\t%s\tWidth\t%s\tError\n",histo->GetXaxis()->GetTitle(),histo->GetYaxis()->GetTitle());
  for(int x=1;x<=histo->GetNbinsX();x++){
    fprintf(fp,"%d\t%3.4f\t%3.4f\t%3.4f\t%3.4f\n",x,histo->GetBinCenter(x),histo->GetBinWidth(x),histo->GetBinContent(x),histo->GetBinError(x));
  }
  fclose(fp);
}
  
//==========================================
void MixedCorrect(TH1F *hPhi, TH1F *hPhiMix, TH1F *hEtaN, TH1F *hEtaNMix, TH1F *hEtaA, TH1F *hEtaAMix, TH2F *hPhiEta, TH2F *hPhiEtaMix){

//Do not use GeoCorr if using this
  // float avePhiMix=hPhiMix->GetSum()/hPhiMix->GetNbinsX();
  float avePhiMix=0, eavePhiMix=0;
  for(int i=0;i<=hPhiMix->GetNbinsX();i++){
    avePhiMix+=hPhiMix->GetBinContent(i);
    eavePhiMix+=pow(hPhiMix->GetBinError(i),2);
  }
  avePhiMix/=hPhiMix->GetNbinsX();
  eavePhiMix=pow(eavePhiMix,0.5)/hPhiMix->GetNbinsX();
  hPhiMix->Scale(1/avePhiMix);
  hPhi->Divide(hPhiMix);

  
  float maxEtaNMix=hEtaNMix->GetBinContent(hEtaNMix->GetNbinsX()/2);
  // float maxEtaNMix=0, emaxEtaNMix=0;
  // for(int i=0;i<=hEtaNMix->GetNbinsX();i++){
  //   aveEtaMix+=hEtaMix->GetBinContent(i);
  //   eaveEtaMix+=pow(hEtaMix->GetBinError(i),2);
  //  }
  //aveEtaMix/=hEtaMix->GetNbinsX();
  // eaveEtaMix=pow(eaveEtaMix,0.5)/hEtaMix->GetNbinsX();
  hEtaNMix->Scale(1/maxEtaNMix);
  hEtaN->Divide(hEtaNMix);
  
  float maxEtaAMix=hEtaAMix->GetBinContent(hEtaAMix->GetNbinsX()/2);
  hEtaAMix->Scale(1/maxEtaAMix);
  hEtaA->Divide(hEtaAMix);

  float maxavePhiEta=0,emaxavePhiEta=0;
  float nbin=0;
  for(int i=1;i<=hPhiEtaMix->GetNbinsX();i++){
    maxavePhiEta+=hPhiEtaMix->GetBinContent(i,hPhiEtaMix->GetNbinsY()/2);
    emaxavePhiEta+=pow(hPhiEtaMix->GetBinError(i,hPhiEtaMix->GetNbinsY()/2),2);
  }
  maxavePhiEta/=hPhiEtaMix->GetNbinsX();
  emaxavePhiEta=pow(emaxavePhiEta,0.5)/hPhiEtaMix->GetNbinsX();
  hPhiEtaMix->Scale(1/maxavePhiEta);
  hPhiEta->Divide(hPhiEtaMix);

  for(int i=1;i<=hPhiMix->GetNbinsX();i++){
    hPhiMix->SetBinContent(i,avePhiMix);
    hPhiMix->SetBinError(i,0);
    }
 
  for(int i=1;i<=hEtaNMix->GetNbinsX();i++){
    hEtaNMix->SetBinContent(i,maxEtaNMix);
    hEtaAMix->SetBinContent(i,maxEtaAMix);
    hEtaNMix->SetBinError(i,0);
    hEtaAMix->SetBinError(i,0);
  }

  for(int i=1;i<=hPhiEta->GetNbinsX();i++){
    for(int j=1;j<=hPhiEta->GetNbinsY();j++){
      hPhiEtaMix->SetBinContent(i,j,maxavePhiEta);
      hPhiEtaMix->SetBinError(i,j,0);
    }
  }
}

void MixedCorrect3(TH2F *hPhiPhi, TH2F *hPhiPhiSS, TH2F *hPhiPhiMix,TH2F *hEtaEta, TH2F *hEtaEtaSS, TH2F *hEtaEtaMix){
  float avePhiPhiMix=hPhiPhiMix->GetSum()/pow(hPhiPhiMix->GetNbinsX(),2);
  cout << "hPhiPhiMix: " << hPhiPhiMix->GetBinContent(1,1) << " " << hPhiPhiMix->GetBinError(1,1) << endl;
  hPhiPhiMix->Scale(1/avePhiPhiMix);
  cout << "hPhiPhiMix: " << hPhiPhiMix->GetBinContent(1,1) << " " << hPhiPhiMix->GetBinError(1,1) << endl;
  hPhiPhi->Divide(hPhiPhiMix);
  hPhiPhiSS->Divide(hPhiPhiMix);

  float maxEtaEtaMix=hEtaEtaMix->GetBinContent(hEtaEtaMix->GetNbinsX()/2,hEtaEtaMix->GetNbinsX()/2);
  hEtaEtaMix->Scale(1/maxEtaEtaMix);
  hEtaEta->Divide(hEtaEtaMix);
  hEtaEtaSS->Divide(hEtaEtaMix);
  
  float conX, conY;
  int nbin=hEtaEta->GetNbinsX();
  float EtaCut=hEtaEta->GetBinCenter(nbin)+hEtaEta->GetBinWidth(1)/2.;

  for(int i=1;i<=hPhiPhi->GetNbinsX();i++){
 
    for(int j=0;j<=hPhiPhi->GetNbinsX();j++){  
      hPhiPhiMix->SetBinContent(i,j,avePhiPhiMix);
      hPhiPhiMix->SetBinError(i,j,0);
    }
  }
  for(int i=1;i<=hEtaEta->GetNbinsX();i++){
    conX=hEtaEta->GetBinCenter(i);
    for(int j=0;j<=hEtaEta->GetNbinsX();j++){
      conY=hEtaEta->GetBinCenter(j);
      if(hEtaEtaMix->GetBinContent(i,j)){
	hEtaEtaMix->SetBinContent(i,j,maxEtaEtaMix);
	hEtaEtaMix->SetBinError(i,j,0);
      }
    }
  }
}
//=================================================================

void ProjPhiPhi(TH2F *shist, TH1F *Non1D, TH1F *Noff1D, TH1F *Aon1D, TH1F *Aoff1D , Float_t NearCut=1.5, float DiagWidth=0.35,int nrand=1000){
  delete gRandom;
  float pi=3.14159265;
  int binxy=shist->GetNbinsX();
  float widthxy=shist->GetXaxis()->GetBinWidth(1);
  gRandom=new TRandom3();
  gRandom->SetSeed(1);
  float s,d;
  int Nbinxy=2.8*NearCut/widthxy;
  float AwayCut=pi-NearCut;
  int Abinxy=2.8*AwayCut/widthxy;
  *Non1D=new TH1F("Non1D","Near On-Diag",Nbinxy,-NearCut,NearCut);
  *Noff1D=new TH1F("Noff1D","Near Off-Diag",Nbinxy,-NearCut,NearCut);
  *Aon1D=new TH1F("Aon1D","Away On-Diag",Abinxy,-AwayCut,AwayCut);
  *Aoff1D=new TH1F("Aoff1D","Away Off-Diag",Abinxy,-AwayCut,AwayCut);

  Non1D->GetXaxis()->SetTitle("#Sigma=(#Delta#phi_{1}+#Delta#phi_{2})/2  or #Delta=(#Delta#phi_{1}-#Delta#phi_{2})/2     ");
  Noff1D->GetXaxis()->SetTitle("#Sigma=(#Delta#phi_{1}+#Delta#phi_{2})/2 or #Delta=(#Delta#phi_{1}-#Delta#phi_{2})/2     ");
  Aon1D->GetXaxis()->SetTitle("#Sigma=(#Delta#phi_{1}+#Delta#phi_{2})/2-#pi or #Delta=(#Delta#phi_{1}-#Delta#phi_{2})/2     ");
  Aoff1D->GetXaxis()->SetTitle("#Sigma=(#Delta#phi_{1}+#Delta#phi_{2})/2-#pi or #Delta=(#Delta#phi_{1}-#Delta#phi_{2})/2     ");
  Non1D->GetYaxis()->SetTitle("1/N_{Trig} dN/d(#Sigma or #Delta)   ");
  Noff1D->GetYaxis()->SetTitle("1/N_{Trig} dN/d(#Sigma or #Delta)   ");
  Aon1D->GetYaxis()->SetTitle("1/N_{Trig} dN/d(#Sigma or #Delta)   ");
  Aoff1D->GetYaxis()->SetTitle("1/N_{Trig} dN/d(#Sigma or #Delta)   ");
  SetTitles1D(Non1D);
  SetTitles1D(Noff1D);
  SetTitles1D(Aon1D);
  SetTitles1D(Aoff1D);

  TH1F *eNon1D=(TH1F*)Non1D->Clone();
  eNon1D->SetName("eNon1D");
  TH1F *eNoff1D=(TH1F*)Noff1D->Clone();
  eNoff1D->SetName("eNoff1D");
  TH1F *eAon1D=(TH1F*)Aon1D->Clone();
  eAon1D->SetName("eAon1D");
  TH1F *eAoff1D=(TH1F*)Aoff1D->Clone();
  eAoff1D->SetName("eAoff1D");
  
  //float binsw=2*pi/binxy*2*pi/(2*pi-2);
  float binsw;
  float NbinsW=Non1D->GetBinWidth(1);
  float AbinsW=Aon1D->GetBinWidth(1);
  float x10,y10,x20,y20,conp1,errp1;
  int nears=10;
  for(int xx1=1;xx1<=binxy;xx1++){
    x10=shist->GetBinCenter(xx1);
    for(int yy1=1;yy1<=binxy;yy1++){
      y10=shist->GetBinCenter(yy1);
      if((x10<NearCut&&y10<NearCut)){binsw=NbinsW/widthxy; nears=1;}
      else if((x10>NearCut&&y10>NearCut)){binsw=AbinsW/widthxy;nears=0;}
      else continue;
      conp1=shist->GetBinContent(xx1,yy1)*binsw/nrand;
      errp1=pow(shist->GetBinError(xx1,yy1)*binsw,2)/nrand;
      //     cout << conp1 << " " << errp1 << " " << endl; 
      // cout << shist->GetBinContent(xx1,yy1) << " " << shist->GetBinError(xx1,yy1) << endl; 
      for(int r1=0;r1<nrand;r1++){
	x20=x10+binsw*(gRandom->Rndm()-0.5);
	y20=y10+binsw*(gRandom->Rndm()-0.5);
	s=(x20+y20)/2;
	d=(x20-y20)/2;
	if(fabs(s-pi)<DiagWidth&&nears==0){
	  Aoff1D->Fill(d,conp1);
	  eAoff1D->Fill(d,errp1);
	  
	}
	
	if(fabs(s)<DiagWidth&&nears==1){
	  Noff1D->Fill(d,conp1);
	  eNoff1D->Fill(d,errp1);
	}
	if(d<DiagWidth&&d>0){
	  if(nears==0){
	    Aon1D->Fill((s-pi),2*conp1);//conp1*2
	    eAon1D->Fill((s-pi),4*errp1);//errp1*4
	  }
	  else if(nears==1){
	    Non1D->Fill(s,2*conp1);//conp1*2
	    eNon1D->Fill(s,4*errp1);//errp1*4
	  }
	}
      }
    }
  }
  for(int xx1=1;xx1<=Nbinxy;xx1++){
    Noff1D->SetBinError(xx1,sqrt(eNoff1D->GetBinContent(xx1)));
    Non1D->SetBinError(xx1,sqrt(eNon1D->GetBinContent(xx1)));
  }
  for(int xx1=1;xx1<=Abinxy;xx1++){
    Aoff1D->SetBinError(xx1,sqrt(eAoff1D->GetBinContent(xx1)));
    Aon1D->SetBinError(xx1,sqrt(eAon1D->GetBinContent(xx1)));
  }
  Non1D->SetMarkerStyle(25);
  Non1D->SetMarkerColor(4);
  Non1D->SetLineColor(4);
  Noff1D->SetMarkerStyle(20);
  Noff1D->SetMarkerColor(2);
  Noff1D->SetLineColor(2);
 Aon1D->SetMarkerStyle(25);
 Aon1D->SetMarkerColor(4);
 Aon1D->SetLineColor(4);
 Aoff1D->SetMarkerStyle(20);
  Aoff1D->SetMarkerColor(2);
  Aoff1D->SetLineColor(2);
}
//========================================
ProjEtaEta(TH2F *shist, TH1F *Non1D, TH1F *Noff1D, float DiagWidth=0.35,int nrand=1000){
  float pi=3.14159265;
  int binxy=shist->GetNbinsX();
  float widthxy=shist->GetXaxis()->GetBinWidth(1);
  gRandom=new TRandom3();
  gRandom->SetSeed(1);
  float NearCut=shist->GetBinCenter(binxy)+shist->GetBinWidth(binxy)/2.;
  float s,d;
  int Nbinxy=2.8*NearCut/widthxy;

  *Non1D=new TH1F("NEon1D","Near On-Diag",Nbinxy,-NearCut,NearCut);
  *Noff1D=new TH1F("NEoff1D","Near Off-Diag",Nbinxy,-NearCut,NearCut);

  Non1D->GetXaxis()->SetTitle("#Sigma=(#Delta#phi_{1}+#Delta#phi_{2})/2  or #Delta=(#Delta#phi_{1}-#Delta#phi_{2})/2     ");
  Noff1D->GetXaxis()->SetTitle("#Sigma=(#Delta#phi_{1}+#Delta#phi_{2})/2 or #Delta=(#Delta#phi_{1}-#Delta#phi_{2})/2     ");
  Non1D->GetYaxis()->SetTitle("1/N_{Trig} dN/d(#Sigma or #Delta)   ");
  Noff1D->GetYaxis()->SetTitle("1/N_{Trig} dN/d(#Sigma or #Delta)   ");
  SetTitles1D(Non1D);
  SetTitles1D(Noff1D);

 TH1F *eNon1D=(TH1F*)Non1D->Clone();
  eNon1D->SetName("eNEon1D");
  TH1F *eNoff1D=(TH1F*)Noff1D->Clone();
  eNoff1D->SetName("eNEoff1D");

  float binsw=Non1D->GetBinWidth(1);
  float x10,y10,x20,y20,conp1,errp1;

  for(int xx1=1;xx1<=binxy;xx1++){
    x10=shist->GetBinCenter(xx1);
    for(int yy1=1;yy1<=binxy;yy1++){
      y10=shist->GetBinCenter(yy1);
      conp1=shist->GetBinContent(xx1,yy1)*binsw/nrand;
      errp1=pow(shist->GetBinError(xx1,yy1)*binsw,2)/nrand;
      for(int r1=0;r1<nrand;r1++){
	x20=x10+binsw*(gRandom->Rndm()-0.5);
	y20=y10+binsw*(gRandom->Rndm()-0.5);
	s=(x20+y20)/2;
	d=(x20-y20)/2;

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