ROOT logo
#ifndef ROOT_TEfficiency_cxx
#define ROOT_TEfficiency_cxx

//standard header
#include <vector>
#include <string>
#include <cmath>
#include <stdlib.h>

//ROOT headers
#include "Math/DistFuncMathCore.h"
#include "TBinomialEfficiencyFitter.h"
#include "TDirectory.h"
#include "TF1.h"
#include "TGraphAsymmErrors.h"
#include "TH1.h"
#include "TH2.h"
#include "TH3.h"
#include "TList.h"
#include "TMath.h"
#include "TROOT.h"
#include "TStyle.h"
#include "TVirtualPad.h"
#include "TError.h"
#include "Math/BrentMinimizer1D.h"
#include "Math/WrappedFunction.h"

//custom headers
#include "TEfficiency.h"

// file with extra class for FC method
#include "TEfficiencyHelper.h"

//default values
const Double_t kDefBetaAlpha = 1;
const Double_t kDefBetaBeta = 1;
const Double_t kDefConfLevel = 0.682689492137; // 1 sigma
const TEfficiency::EStatOption kDefStatOpt = TEfficiency::kFCP;
const Double_t kDefWeight = 1;

ClassImp(TEfficiency)

//______________________________________________________________________________
/*******************************************************************************
 Begin_Html
 <center><h2>TEfficiency - a class to handle efficiency
 histograms</h2></center>
 <ol style="list-style-type: upper-roman;">
 <li><a href="#over">Overview</a></li>
 <li><a href="#create">Creating a TEfficiency object</a></li>
 <li><a href="#fill">Fill in events</a></li>
 <li><a href="#stat">Statistic options</a></li>
 <ol><li><a href="#compare">Coverage probabilities for different methods</a></li></ol>
 <li><a href="#cm">Merging and combining TEfficiency objects</a></li>
 <ol>
 <li><a href="#merge">When should I use merging?</a></li>
 <li><a href="#comb">When should I use combining?</a></li>
 </ol>
 <li><a href="#other">Further operations</a>
 <ol>
 <li><a href="#histo">Information about the internal histograms</a></li>
 <li><a href="#fit">Fitting</a></li>
 <li><a href="#draw">Draw a TEfficiency object</a></li>
 </ol>
 <li><a href="#class">TEfficiency class</a></li>
 </ol>

 <h3><a name="over">I. Overview</a></h3>
 This class handles the calculation of efficiencies and their uncertainties. It
 provides several statistical methods for calculating frequentist and bayesian
 confidence intervals as well as a function for combining several efficiencies.
 <br />
 Efficiencies have a lot of applications and meanings but in principle they can
 be described by the fraction of good/passed events k out of sample containing
 N events. One is usually interested in the dependency of the efficiency on other
 (binned) variables. The number of passed and total events is therefore stored
 internally in two histograms (<a href="http://root.cern.ch/root/html/TEfficiency.html#TEfficiency:fTotalHistogram">fTotalHistogram</a> and
 <a href="http://root.cern.ch/root/html/TEfficiency.html#TEfficiency:fPassedHistogram">fPassedHistogram</a>). Then the
 efficiency as well as its upper and lower error an be calculated for each bin
 individually.<br />
 As the efficiency can be regarded as a parameter of a binomial distribution, the
 number of pass ed and total events must always be integer numbers. Therefore a
 filling with weights is not possible however you can assign a global weight to each
 TEfficiency object (<a href="http://root.cern.ch/root/html/TEfficiency.html#TEfficiency:SetWeight">SetWeight</a>). It is necessary to create one TEfficiency object
 for each weight if you investigate a process involving different weights. This
 procedure needs more effort but enables you to re-use the filled object in cases
 where you want to change one or more weights. This would not be possible if all
 events with different weights were filled in the same histogram.

 <h3><a name="create">II. Creating a TEfficiency object</a></h3>
 If you start a new analysis, it is highly recommended to use the TEfficiency class
 from the beginning. You can then use one of the constructors for fixed or
 variable bin size and your desired dimension. These constructors append the
 created TEfficiency object to the current directory. So it will be written
 automatically to a file during the next <a href="http://root.cern.ch/root/html/TFile.html#TFile:Write">TFile::Write</a> command.
 <div class="code"><pre>
 <b>Example:</b>
 create a twodimensional TEfficiency object with
 - name = "eff"
 - title = "my efficiency"
 - axistitles: x, y and LaTeX formated epsilon as label for Z axis
 - 10 bins with constant bin width (= 1) along X axis starting at 0 (lower edge
 from first bin) upto 10 (upper edge of last bin)
 - 20 bins with constant bin width (= 0.5) along Y axis starting at -5 (lower
 edge from first bin) upto 5 (upper edge of last bin)
 TEfficiency* pEff = new TEfficiency("eff","my efficiency;x;y;#epsilon",10,0,10,20,-5,5);
 </pre></div><div class="clear" />
 If you already have two histograms filled with the number of passed and total
 events, you will use the constructor <a href="http://root.cern.ch/root/html/TEfficiency.html#TEfficiency:TEfficiency%1">TEfficiency(const TH1& passed,const TH1& total)</a>
 to construct the TEfficiency object. The histograms "passed" and "total" have
 to fullfill the conditions  mentioned in <a href="http://root.cern.ch/root/html/TEfficiency.html#TEfficiency:CheckConsistency">CheckConsistency</a>, otherwise the construction will fail.
 As the histograms already exist, the new TEfficiency is by default <b>not</b> attached
 to the current directory to avoid duplication of data. If you want to store the
 new object anyway, you can either write it directly by calling <a href="http://root.cern.ch/root/html/TObject.html#TObject:Write">Write</a> or attach it to a directory using <a href="http://root.cern.ch/root/html/TEfficiency.html#TEfficiency:SetDirectory">SetDirectory</a>.
 This also applies for TEfficiency objects created by the copy constructor <a href="http://root.cern.ch/root/html/TEfficiency.html#TEfficiency:TEfficiency%8">TEfficiency(const TEfficiency& rEff)</a>.
 <div class="code">
 <pre>
 <b>Example 1:</b>
 TEfficiency* pEff = 0;
 TFile* pFile = new TFile("myfile.root","recreate");

 //h_pass and h_total are valid and consistent histograms
 if(TEfficiency::CheckConsistency(h_pass,h_total))
 {
 pEff = new TEfficiency(h_pass,h_total);
 // this will write the TEfficiency object to "myfile.root"
 // AND pEff will be attached to the current directory
 pEff->Write();
 }

 <b>Example 2:</b>
 TEfficiency* pEff = 0;
 TFile* pFile = new TFile("myfile.root","recreate");

 //h_pass and h_total are valid and consistent histograms
 if(TEfficiency::CheckConsistency(h_pass,h_total))
 {
 pEff = new TEfficiency(h_pass,h_total);
 //this will attach the TEfficiency object to the current directory
 pEff->SetDirectory(gDirectory);
 //now all objects in gDirectory will be written to "myfile.root"
 pFile->Write();
 }
 </pre>
 </div><div class="clear" />
 In the case that you already have two filled histograms and you only want to
 plot them as a graph, you should rather use <a href="http://root.cern.ch/root/html/TGraphAsymmErrors.html#TGraphAsymmErrors:TGraphAsymmErrors%8">TGraphAsymmErrors::TGraphAsymmErrors(const TH1* pass,const TH1* total,Option_t* opt)</a>
 to create a graph object.

 <h3><a name="fill">III. Filling with events</a></h3>
 You can fill the TEfficiency object by calling the <a href="http://root.cern.ch/root/html/TEfficiency.html#TEfficiency:Fill">Fill(Bool_t bPassed,Double_t x,Double_t y,Double_t z)</a> method.
 The boolean flag "bPassed" indicates whether the current event is a good
 (both histograms are filled) or not (only <a href="http://root.cern.ch/root/html/TEfficiency.html#TEfficiency:fTotalHistogram">fTotalHistogram</a> is filled).
 The variables x,y and z determine the bin which is filled. For lower
 dimensions the z- or even the y-value may be omitted.
 End_Html
 Begin_Macro(source)
 {
 //canvas only needed for this documentation
 TCanvas* c1 = new TCanvas("example","",600,400);
 c1->SetFillStyle(1001);
 c1->SetFillColor(kWhite);

 //create one-dimensional TEfficiency object with fixed bin size
 TEfficiency* pEff = new TEfficiency("eff","my efficiency;x;#epsilon",20,0,10);
 TRandom3 rand;

 bool bPassed;
 double x;
 for(int i=0; i<10000; ++i)
 {
 //simulate events with variable under investigation
 x = rand.Uniform(10);
 //check selection: bPassed = DoesEventPassSelection(x)
 bPassed = rand.Rndm() < TMath::Gaus(x,5,4);
 pEff->Fill(bPassed,x);
 }

 pEff->Draw("AP");

 //only for this documentation
 return c1;
 }
 End_Macro
 Begin_Html
 You can also set the number of passed or total events for a bin directly by
 using the <a href="http://root.cern.ch/root/html/TEfficiency.html#TEfficiency:SetPassedEvents">SetPassedEvents</a> or <a href="http://root.cern.ch/root/html/TEfficiency.html#TEfficiency:SetTotalEvents">SetTotalEvents</a> method.

 <h3><a name="stat">IV. Statistic options</a></h3>
 The calculation of the estimated efficiency depends on the chosen statistic
 option. Let k denotes the number of passed events and N the number of total
 events.<br />
 <b>Frequentist methods</b><br />
 The expectation value of the number of passed events is given by the true
 efficiency times the total number of events. One can estimate the efficiency
 by replacing the expected number of passed events by the observed number of
 passed events. End_Html
 Begin_Latex
 #LT k #GT = #epsilon #times N    #Rightarrow    #hat{#varepsilon} = #frac{k}{N}
 End_Latex
 Begin_Html
 <b>Bayesian methods</b><br />
 In bayesian statistics a likelihood-function (how probable is it to get the
 observed data assuming a true efficiency) and a prior probability (what is the
 probability that a certain true efficiency is actually realised) are used to
 determine a posterior probability by using Bayes theorem. At the moment, only
 beta distributions (have 2 free parameters) are supported as prior
 probabilities.
 End_Html
 Begin_Latex(separator='=',align='rl')
 P(#epsilon | k ; N) = #frac{1}{norm} #times P(k | #epsilon ; N) #times Prior(#epsilon)
 P(k | #epsilon ; N) = Binomial(N,k) #times #epsilon^{k} #times (1 - #epsilon)^{N - k} ... binomial distribution
 Prior(#epsilon) = #frac{1}{B(#alpha,#beta)} #times #epsilon ^{#alpha - 1} #times (1 - #epsilon)^{#beta - 1} #equiv Beta(#epsilon; #alpha,#beta)
 #Rightarrow P(#epsilon | k ; N) = #frac{1}{norm'} #times #epsilon^{k + #alpha - 1} #times (1 - #epsilon)^{N - k + #beta - 1} #equiv Beta(#epsilon; k + #alpha, N - k + #beta)
 End_Latex
 Begin_Html
 By default the expectation value of this posterior distribution is used as estimator for the efficiency:
 End_Html
 Begin_Latex
 #hat{#varepsilon} = #frac{k + #alpha}{N + #alpha + #beta}
 End_Latex
 Begin_Html
 Optionally the mode can also be used as value for the estimated efficiency. This can be done by calling SetBit(kPosteriorMode) or
 <a href="http://root.cern.ch/root/html/TEfficiency.html#TEfficiency:SetPosteriorMode">SetPosteriorMode</a>. In this case the estimated efficiency is:
 End_Html
 Begin_Latex
 #hat{#varepsilon} = #frac{k + #alpha -1}{N + #alpha + #beta - 2}
 End_Latex
 Begin_Html
 In the case of a uniform prior distribution, B(x,1,1), the posterior mode is k/n, equivalent to the frequentist estimate (the maximum likelihood value).

 The statistic options also specifiy which confidence interval is used for calculating
 the uncertainties of the efficiency. The following properties define the error
 calculation:
 <ul>
 <li><b>fConfLevel:</b> desired confidence level: 0 < fConfLevel < 1 (<a href="http://root.cern.ch/root/html/TEfficiency.html#TEfficiency:GetConfidenceLevel">GetConfidenceLevel</a> / <a href="http://root.cern.ch/root/html/TEfficiency.html#TEfficiency:SetConfidenceLevel">SetConfidenceLevel</a>)</li>
 <li><b>fStatisticOption:</b> defines which method is used to calculate the boundaries of the confidence interval (<a href="http://root.cern.ch/root/html/TEfficiency.html#TEfficiency:SetStatisticOption">SetStatisticOption</a>)</li>
 <li><b>fBeta_alpha, fBeta_beta:</b> parameters for the prior distribution which is only used in the bayesian case (<a href="http://root.cern.ch/root/html/TEfficiency.html#TEfficiency:GetBetaAlpha">GetBetaAlpha</a> / <a href="http://root.cern.ch/root/html/TEfficiency.html#TEfficiency:GetBetaBeta">GetBetaBeta</a> / <a href="http://root.cern.ch/root/html/TEfficiency.html#TEfficiency:SetBetaAlpha">SetBetaAlpha</a> / <a href="http://root.cern.ch/root/html/TEfficiency.html#TEfficiency:SetBetaBeta">SetBetaBeta</a>)</li>
 <li><b>kIsBayesian:</b> flag whether bayesian statistics are used or not (<a href="http://root.cern.ch/root/html/TEfficiency.html#TEfficiency:UsesBayesianStat">UsesBayesianStat</a>)</li>
 <li><b>kShortestInterval:</b> flag whether shortest interval (instead of central one) are used in case of Bayesian statistics  (<a href="http://root.cern.ch/root/html/TEfficiency.html#TEfficiency:UsesShortestInterval">UsesShortestInterval</a>). Normally shortest interval should be used in combination with the mode (see <a href="http://root.cern.ch/root/html/TEfficiency.html#TEfficiency:UsesPosteriorMode">UsesPosteriorMode</a>)</li>
 <li><b>fWeight:</b> global weight for this TEfficiency object which is used during combining or merging with other TEfficiency objects(<a href="http://root.cern.ch/root/html/TEfficiency.html#TEfficiency:GetWeight">GetWeight</a> / <a href="http://root.cern.ch/root/html/TEfficiency.html#TEfficiency:SetWeight">SetWeight</a>)</li>
 </ul>
 In the following table the implemented confidence intervals are listed
 with their corresponding statistic option. For more details on the calculation,
 please have a look at the the mentioned functions.<br /><br />
 <table align="center" border="1" cellpadding="5" rules="rows" vspace="10">
 <caption align="bottom">implemented confidence intervals and their options</caption>
 <tr>
 <th>name</th><th>statistic option</th><th>function</th><th>kIsBayesian</th><th>parameters</th>
 </tr>
 <tr>
 <td>Clopper-Pearson</td><td>kFCP</td>
 <td>
 <a href="http://root.cern.ch/root/html/TEfficiency.html#TEfficiency:ClopperPearson">ClopperPearson</a>
 </td>
 <td>false</td>
 <td>
 <ul><li>total events</li><li>passed events</li><li>confidence level</li></ul>
 </td>
 </tr>
 <tr>
 <td>normal approximation</td><td>kFNormal</td>
 <td>
 <a href="http://root.cern.ch/root/html/TEfficiency.html#TEfficiency:Normal">Normal</a>
 </td>
 <td>false</td>
 <td>
 <ul><li>total events</li><li>passed events</li><li>confidence level</li></ul>
 </td>
 </tr>
 <tr>
 <td>Wilson</td><td>kFWilson</td>
 <td>
 <a href="http://root.cern.ch/root/html/TEfficiency.html#TEfficiency:Wilson">Wilson</a>
 </td>
 <td>false</td>
 <td>
 <ul><li>total events</li><li>passed events</li><li>confidence level</li></ul>
 </td>
 </tr>
 <tr>
 <td>Agresti-Coull</td><td>kFAC</td>
 <td>
 <a href="http://root.cern.ch/root/html/TEfficiency.html#TEfficiency:AgrestiCoull">AgrestiCoull</a>
 </td>
 <td>false</td>
 <td>
 <ul><li>total events</li><li>passed events</li><li>confidence level</li></ul>
 </td>
 </tr>
 <tr>
 <td>Feldman-Cousins</td><td>kFFC</td>
 <td>
 <a href="http://root.cern.ch/root/html/TEfficiency.html#TEfficiency:FeldmanCousins">FeldmanCousins</a>
 </td>
 <td>false</td>
 <td>
 <ul><li>total events</li><li>passed events</li><li>confidence level</li></ul>
 </td>
 </tr>
 <tr>
 <td>Jeffrey</td><td>kBJeffrey</td>
 <td>
 <a href="http://root.cern.ch/root/html/TEfficiency.html#TEfficiency:Bayesian">Bayesian</a>
 </td>
 <td>true</td>
 <td>
 <ul><li>total events</li><li>passed events</li><li>confidence level</li><li>fBeta_alpha = 0.5</li><li>fBeta_beta = 0.5</li></ul>
 </td>
 </tr>
 <td>Uniform prior</td><td>kBUniform</td>
 <td>
 <a href="http://root.cern.ch/root/html/TEfficiency.html#TEfficiency:Bayesian">Bayesian</a>
 </td>
 <td>true</td>
 <td>
 <ul><li>total events</li><li>passed events</li><li>confidence level</li><li>fBeta_alpha = 1</li><li>fBeta_beta = 1</li></ul>
 </td>
 </tr>
 <td>custom prior</td><td>kBBayesian</td>
 <td>
 <a href="http://root.cern.ch/root/html/TEfficiency.html#TEfficiency:Bayesian">Bayesian</a>
 </td>
 <td>true</td>
 <td>
 <ul><li>total events</li><li>passed events</li><li>confidence level</li><li>fBeta_alpha</li><li>fBeta_beta</li></ul>
 </td>
 </tr>
 </table>
 <br />
 The following example demonstrates the effect of different statistic options and
 confidence levels.
 End_Html
 Begin_Macro(source)
 {
 //canvas only needed for the documentation
 TCanvas* c1 = new TCanvas("c1","",600,400);
 c1->Divide(2);
 c1->SetFillStyle(1001);
 c1->SetFillColor(kWhite);

 //create one-dimensional TEfficiency object with fixed bin size
 TEfficiency* pEff = new TEfficiency("eff","different confidence levels;x;#epsilon",20,0,10);
 TRandom3 rand;

 bool bPassed;
 double x;
 for(int i=0; i<1000; ++i)
 {
 //simulate events with variable under investigation
 x = rand.Uniform(10);
 //check selection: bPassed = DoesEventPassSelection(x)
 bPassed = rand.Rndm() < TMath::Gaus(x,5,4);
 pEff->Fill(bPassed,x);
 }

 //set style attributes
 pEff->SetFillStyle(3004);
 pEff->SetFillColor(kRed);

 //copy current TEfficiency object and set new confidence level
 TEfficiency* pCopy = new TEfficiency(*pEff);
 pCopy->SetConfidenceLevel(0.90);

 //set style attributes
 pCopy->SetFillStyle(3005);
 pCopy->SetFillColor(kBlue);

 c1->cd(1);

 //add legend
 TLegend* leg1 = new TLegend(0.3,0.1,0.7,0.5);
 leg1->AddEntry(pEff,"95%","F");
 leg1->AddEntry(pCopy,"68.3%","F");

 pEff->Draw("A4");
 pCopy->Draw("same4");
 leg1->Draw("same");

 //use same confidence level but different statistic methods
 TEfficiency* pEff2 = new TEfficiency(*pEff);
 TEfficiency* pCopy2 = new TEfficiency(*pEff);

 pEff2->SetStatisticOption(TEfficiency::kFNormal);
 pCopy2->SetStatisticOption(TEfficiency::kFAC);

 pEff2->SetTitle("different statistic options;x;#epsilon");

 //set style attributes
 pCopy2->SetFillStyle(3005);
 pCopy2->SetFillColor(kBlue);

 c1->cd(2);

 //add legend
 TLegend* leg2 = new TLegend(0.3,0.1,0.7,0.5);
 leg2->AddEntry(pEff2,"kFNormal","F");
 leg2->AddEntry(pCopy2,"kFAC","F");

 pEff2->Draw("a4");
 pCopy2->Draw("same4");
 leg2->Draw("same");

 //only for this documentation
 c1->cd(0);
 return c1;
 }
 End_Macro
 Begin_Html
 The prior probability of the efficiency in bayesian statistics can be given
 in terms of a beta distribution. The beta distribution has to positive shape
 parameters. The resulting priors for different combinations of these shape
 parameters are shown in the plot below.
 End_Html
 Begin_Macro(source)
 {
 //canvas only needed for the documentation
 TCanvas* c1 = new TCanvas("c1","",600,400);
 c1->SetFillStyle(1001);
 c1->SetFillColor(kWhite);

 //create different beta distributions
 TF1* f1 = new TF1("f1","TMath::BetaDist(x,1,1)",0,1);
 f1->SetLineColor(kBlue);
 TF1* f2 = new TF1("f2","TMath::BetaDist(x,0.5,0.5)",0,1);
 f2->SetLineColor(kRed);
 TF1* f3 = new TF1("f3","TMath::BetaDist(x,1,5)",0,1);
 f3->SetLineColor(kGreen+3);
 f3->SetTitle("Beta distributions as priors;#epsilon;P(#epsilon)");
 TF1* f4 = new TF1("f4","TMath::BetaDist(x,4,3)",0,1);
 f4->SetLineColor(kViolet);

 //add legend
 TLegend* leg = new TLegend(0.25,0.5,0.85,0.89);
 leg->SetFillColor(kWhite);
 leg->SetFillStyle(1001);
 leg->AddEntry(f1,"a=1, b=1","L");
 leg->AddEntry(f2,"a=0.5, b=0.5","L");
 leg->AddEntry(f3,"a=1, b=5","L");
 leg->AddEntry(f4,"a=4, b=3","L");

 f3->Draw();
 f1->Draw("same");
 f2->Draw("Same");
 f4->Draw("same");
 leg->Draw("same");

 //only for this documentation
 return c1;
 }
 End_Macro
 Begin_Html

 <h4><a name="compare">IV.1 Coverage probabilities for different methods</a></h4>
 The following pictures illustrate the actual coverage probability for the
 different values of the true efficiency and the total number of events when a
 confidence level of 95% is desired.
 <p><img src="http://root.cern.ch/drupal/sites/default/files/images/normal95.gif" alt="normal approximation" width="600" height="400" /></p>
 <p><img src="http://root.cern.ch/drupal/sites/default/files/images/wilson95.gif" alt="wilson" width="600" height="400" /></p>
 <p><img src="http://root.cern.ch/drupal/sites/default/files/images/ac95.gif" alt="agresti coull" width="600" height="400" /></p>
 <p><img src="http://root.cern.ch/drupal/sites/default/files/images/cp95.gif" alt="clopper pearson" width="600" height="400" /></p>
 <p><img src="http://root.cern.ch/drupal/sites/default/files/images/uni95.gif" alt="uniform prior" width="600" height="400" /></p>
 <p><img src="http://root.cern.ch/drupal/sites/default/files/images/jeffrey95.gif" alt="jeffrey prior" width="600" height="400" /></p>

 The average (over all possible true efficiencies) coverage probability for
 different number of total events is shown in the next picture.
 <p><img src="http://root.cern.ch/drupal/sites/default/files/images/av_cov.png" alt="average coverage" width="600" height="400" /></p>
 <h3><a name="cm">V. Merging and combining TEfficiency objects</a></h3>
 In many applications the efficiency should be calculated for an inhomogenous
 sample in the sense that it contains events with different weights. In order
 to be able to determine the correct overall efficiency, it is necessary to
 use for each subsample (= all events with the same weight) a different
 TEfficiency object. After finsihing your analysis you can then construct the
 overall efficiency with its uncertainty.<br />
 This procedure has the advantage that you can change the weight of one
 subsample easily without rerunning the whole analysis. On the other hand more
 efford is needed to handle several TEfficiency objects instead of one
 histogram. In the case of many different or even continuously distributed
 weights this approach becomes cumbersome. One possibility to overcome this
 problem is the usage of binned weights.<br /><br />
 <b>Example</b><br />
 In high particle physics weights arises from the fact that you want to
 normalise your results to a certain reference value. A very common formula for
 calculating weights is End_Html
 Begin_Latex(separator='-')
 w = #frac{#sigma L}{N_{gen} #epsilon_{trig}} - #sigma ... cross section
 - L ... luminosity
 - N_{gen} ... number of generated events
 - #epsilon_{trig} ... (known) trigger efficiency
 End_Latex
 Begin_Html
 The reason for different weights can therefore be:<ul>
 <li>different processes</li>
 <li>other integrated luminosity</li>
 <li>varying trigger efficiency</li>
 <li>different sample sizes</li>
 <li>...</li>
 <li>or even combination of them</li>
 </ul>
 Depending on the actual meaning of different weights in your case, you
 should either merge or combine them to get the overall efficiency.

 <h4><a name="merge">V.1 When should I use merging?</a></h4>
 If the weights are artificial and do not represent real alternative hypotheses,
 you should merge the different TEfficiency objects. That means especially for
 the bayesian case that the prior probability should be the same for all merged
 TEfficiency objects. The merging can be done by invoking one of the following
 operations:
 <ul>
 <li> <b>eff1</b>.<a href="http://root.cern.ch/root/html/TEfficiency.html#TEfficiency:Add">Add</a>(eff2)</li>
 <li> <b>eff1</b> <a href="http://root.cern.ch/root/html/TEfficiency.html#TEfficiency:operator+=">+=</a> eff2</li>
 <li> <b>eff</b> = eff1 + eff2</li>
 </ul>
 The result of the merging is stored in the TEfficiency object which is marked
 bold above. The contents of the internal histograms of both TEfficiency
 objects are added and a new weight is assigned. The statistic options are not
 changed.
 End_Html
 Begin_Latex #frac{1}{w_{new}} = #frac{1}{w_{1}} + #frac{1}{w_{2}}End_Latex
 Begin_Html
 <b>Example:</b><br />
 If you use two samples with different numbers of generated events for the same
 process and you want to normalise both to the same integrated luminosity and
 trigger efficiency, the different weights then arise just from the fact that
 you have different numbers of events. The TEfficiency objects should be merged
 because the samples do not represent true alternatives. You expect the same
 result as if you would have a big sample with all events in it.
 End_Html
 Begin_Latex
 w_{1} = #frac{#sigma L}{#epsilon N_{1}}, w_{2} = #frac{#sigma L}{#epsilon N_{2}} #Rightarrow w_{new} = #frac{#sigma L}{#epsilon (N_{1} + N_{2})} = #frac{1}{#frac{1}{w_{1}} + #frac{1}{w_{2}}}
 End_Latex
 Begin_Html

 <h4><a name="comb">V.2 When should I use combining?</a></h4>
 You should combine TEfficiency objects whenever the weights represent
 alternatives processes for the efficiency. As the combination of two TEfficiency
 objects is not always consistent with the representation by two internal
 histograms, the result is not stored in a TEfficiency object but a TGraphAsymmErrors
 is returned which shows the estimated combined efficiency and its uncertainty
 for each bin. At the moment the combination method <a href="http://root.cern.ch/root/html/TEfficiency.html#TEfficiency:Combine">Combine </a>only supports combination of 1-dimensional efficiencies in a bayesian approach.<br />
 For calculating the combined efficiency and its uncertainty for each bin only Bayesian statistics is used. No frequentists methods are presently
 supported for computing the combined efficiency and its confidence interval.
 In the case of the Bayesian statistics a combined posterior is constructed taking into account the weight of each TEfficiency object. The same prior is used
 for all the TEfficiency objects.
 End_Html
 Begin_Latex
 P_{comb}(#epsilon | {w_{i}}, {k_{i}} , {N_{i}}) = #frac{1}{norm} #prod_{i}{L(k_{i} | N_{i}, #epsilon)}^{w_{i}} #Pi( #epsilon )
 L(k_{i} | N_{i}, #epsilon) is the likelihood function for the sample i ( a Binomial distribution)
 #Pi( #epsilon) is the prior, a beta distribution B(#epsilon, #alpha, #beta).
 The resulting combined posterior is
 P_{comb}(#epsilon |{w_{i}}; {k_{i}}; {N_{i}}) = B(#epsilon, #sum_{i}{ w_{i} k_{i}} + #alpha, #sum_{i}{ w_{i}(n_{i}-k_{i})}+#beta)
 #hat{#varepsilon} = #int_{0}^{1} #epsilon #times P_{comb}(#epsilon | {k_{i}} , {N_{i}}) d#epsilon
 confidence level = 1 - #alpha
 #frac{#alpha}{2} = #int_{0}^{#epsilon_{low}} P_{comb}(#epsilon | {k_{i}} , {N_{i}}) d#epsilon ... defines lower boundary
 1- #frac{#alpha}{2} = #int_{0}^{#epsilon_{up}} P_{comb}(#epsilon | {k_{i}} , {N_{i}}) d#epsilon ... defines upper boundary
 End_Latex
 Begin_Html
 <b>Example:</b><br />
 If you use cuts to select electrons which can originate from two different
 processes, you can determine the selection efficiency for each process. The
 overall selection efficiency is then the combined efficiency. The weights to be used in the
 combination should be the probability that an
 electron comes from the corresponding process.
 End_Html
 Begin_Latex
 p_{1} = #frac{#sigma_{1}}{#sigma_{1} + #sigma_{2}} = #frac{N_{1}w_{1}}{N_{1}w_{1} + N_{2}w_{2}}
 p_{2} = #frac{#sigma_{2}}{#sigma_{1} + #sigma_{2}} = #frac{N_{2}w_{2}}{N_{1}w_{1} + N_{2}w_{2}}
 End_Latex
 Begin_Html
 <h3><a name="other">VI. Further operations</a></h3>

 <h4><a name="histo">VI.1 Information about the internal histograms</a></h4>
 The methods <a href="http://root.cern.ch/root/html/TEfficiency.html#TEfficiency:GetPassedHistogram">GetPassedHistogram</a> and <a href="http://root.cern.ch/root/html/TEfficiency.html#TEfficiency:GetTotalHistogram">GetTotalHistogram</a>
 return a constant pointer to the internal histograms. They can be used to
 obtain information about the internal histograms (e.g. the binning, number of passed / total events in a bin, mean values...).
 One can obtain a clone of the internal histograms by calling <a href="http://root.cern.ch/root/html/TEfficiency.html#TEfficiency:GetCopyPassedHisto">GetCopyPassedHisto</a> or <a href="http://root.cern.ch/root/html/TEfficiency.html#TEfficiency:GetCopyTotalHisto">GetCopyTotalHisto</a>.
 The returned histograms are completely independent from the current
 TEfficiency object. By default, they are not attached to a directory to
 avoid the duplication of data and the user is responsible for deleting them.
 <div class="code">
 <pre>
 <b>Example:</b>
 //open a root file which contains a TEfficiency object
 TFile* pFile = new TFile("myfile.root","update");

 //get TEfficiency object with name "my_eff"
 TEfficiency* pEff = (TEfficiency*)pFile->Get("my_eff");

 //get clone of total histogram
 TH1* clone = pEff->GetCopyTotalHisto();

 //change clone...
 //save changes of clone directly
 clone->Write();
 //or append it to the current directoy and write the file
 //clone->SetDirectory(gDirectory);
 //pFile->Wrtie();

 //delete histogram object
 delete clone;
 clone = 0;
 </pre>
 </div><div class="clear" />
 It is also possible to set the internal total or passed histogram by using the
 methods <a href="http://root.cern.ch/root/html/TEfficiency.html#TEfficiency:SetPassedHistogram">SetPassedHistogram</a> or
 <a href="http://root.cern.ch/root/html/TEfficiency.html#TEfficiency:SetTotalHistogram">SetTotalHistogram</a>.
 In order to ensure the validity of the TEfficiency object, the consistency of the
 new histogram and the stored histogram is checked. It sometimes might be
 impossible to change the histograms in a consistent way. Therefore one can force
 the replacement by passing the option "f". Then the user has to ensure that the
 other internal histogram is replaced as well and that the TEfficiency object is
 in a valid state.

 <h4><a name="fit">VI.2 Fitting</a></h4>
 The efficiency can be fitted using the <a href="http://root.cern.ch/root/html/TEfficiency.html#TEfficiency:Fit">Fit</a> function which uses internally the <a href="http://root.cern.ch/root/html/TBinomialEfficiencyFitter.html#TBinomialEfficiencyFitter:Fit">TBinomialEfficiencyFitter::Fit</a> method.
 As this method is using a maximum-likelihood-fit, it is necessary to initialise
 the given fit function with reasonable start values.
 The resulting fit function is attached to the list of associated functions and
 will be drawn automatically during the next <a href="http://root.cern.ch/root/html/TEfficiency.html#TEfficiency:Draw">Draw</a> command.
 The list of associated function can be modified by using the pointer returned
 by <a href="http://root.cern.ch/root/html/TEfficiency.html#TEfficiency:GetListOfFunctions">GetListOfFunctions</a>.
 End_Html
 Begin_Macro(source)
 {
 //canvas only needed for this documentation
 TCanvas* c1 = new TCanvas("example","",600,400);
 c1->SetFillStyle(1001);
 c1->SetFillColor(kWhite);

 //create one-dimensional TEfficiency object with fixed bin size
 TEfficiency* pEff = new TEfficiency("eff","my efficiency;x;#epsilon",20,0,10);
 TRandom3 rand;

 bool bPassed;
 double x;
 for(int i=0; i<10000; ++i)
 {
 //simulate events with variable under investigation
 x = rand.Uniform(10);
 //check selection: bPassed = DoesEventPassSelection(x)
 bPassed = rand.Rndm() < TMath::Gaus(x,5,4);
 pEff->Fill(bPassed,x);
 }

 //create a function for fitting and do the fit
 TF1* f1 = new TF1("f1","gaus",0,10);
 f1->SetParameters(1,5,2);
 pEff->Fit(f1);

 //create a threshold function
 TF1* f2 = new TF1("thres","0.8",0,10);
 f2->SetLineColor(kRed);
 //add it to the list of functions
 //use add first because the parameters of the last function will be displayed
 pEff->GetListOfFunctions()->AddFirst(f2);

 pEff->Draw("AP");

 //only for this documentation
 return c1;
 }
 End_Macro
 Begin_Html

 <h4><a name="draw">VI.3 Draw a TEfficiency object</a></h4>
 A TEfficiency object can be drawn by calling the usual <a href="http://root.cern.ch/root/html/TEfficiency.html#TEfficiency:Draw">Draw</a> method.
 At the moment drawing is only supported for 1- and 2-dimensional TEfficiency
 objects. In the 1-dimensional case you can use the same options as for the <br />
 <a href="http://root.cern.ch/root/html/TGraph.html#TGraph:Draw">TGraphAsymmErrors::Draw</a>
 method. For 2-dimensional TEfficiency objects you can pass the same options as
 for a <a href="http://root.cern.ch/root/html/TH1.html#TH1:Draw">TH2::Draw</a> object.

 <h3 style="margin-bottom:-3em;"><a name="class">VII. TEfficiency class</a></h3>

 End_Html
 ******************************************************************************/
//______________________________________________________________________________

//______________________________________________________________________________
TEfficiency::TEfficiency():
fBeta_alpha(kDefBetaAlpha),
fBeta_beta(kDefBetaBeta),
fBoundary(0),
fConfLevel(kDefConfLevel),
fDirectory(0),
fFunctions(0),
fPaintGraph(0),
fPaintHisto(0),
fPassedHistogram(0),
fTotalHistogram(0),
fWeight(kDefWeight)
{
   //default constructor
   //
   //should not be used explicitly

   SetStatisticOption(kDefStatOpt);

   // create 2 dummy histograms
   fPassedHistogram = new TH1F("h_passed","passed",10,0,10);
   fTotalHistogram = new TH1F("h_total","total",10,0,10);
}

//______________________________________________________________________________
TEfficiency::TEfficiency(const TH1& passed,const TH1& total):
fBeta_alpha(kDefBetaAlpha),
fBeta_beta(kDefBetaBeta),
fConfLevel(kDefConfLevel),
fDirectory(0),
fFunctions(0),
fPaintGraph(0),
fPaintHisto(0),
fWeight(kDefWeight)
{
   //constructor using two existing histograms as input
   //
   //Input: passed - contains the events fullfilling some criteria
   //       total  - contains all investigated events
   //
   //Notes: - both histograms have to fullfill the conditions of CheckConsistency (with option 'w')
   //       - dimension of the resulating efficiency object depends
   //         on the dimension of the given histograms
   //       - Clones of both histograms are stored internally
   //       - The function SetName(total.GetName() + "_clone") is called to set
   //         the names of the new object and the internal histograms..
   //       - The created TEfficiency object is NOT appended to a directory. It
   //         will not be written to disk during the next TFile::Write() command
   //         in order to prevent duplication of data. If you want to save this
   //         TEfficiency object anyway, you can either append it to a
   //         directory by calling SetDirectory(TDirectory*) or write it
   //         explicitly to disk by calling Write().

   //check consistency of histograms
   if(CheckConsistency(passed,total,"w")) {
      Bool_t bStatus = TH1::AddDirectoryStatus();
      TH1::AddDirectory(kFALSE);
      fTotalHistogram = (TH1*)total.Clone();
      fPassedHistogram = (TH1*)passed.Clone();
      TH1::AddDirectory(bStatus);

      TString newName = total.GetName();
      newName += TString("_clone");
      SetName(newName);

      // are the histograms filled with weights?
      if(!CheckEntries(passed,total))
      {
         Info("TEfficiency","given histograms are filled with weights");
         SetUseWeightedEvents();
      }
   }
   else {
      Error("TEfficiency(const TH1&,const TH1&)","histograms are not consistent -> results are useless");
      Warning("TEfficiency(const TH1&,const TH1&)","using two empty TH1D('h1','h1',10,0,10)");

      Bool_t bStatus = TH1::AddDirectoryStatus();
      TH1::AddDirectory(kFALSE);
      fTotalHistogram = new TH1D("h1_total","h1 (total)",10,0,10);
      fPassedHistogram = new TH1D("h1_passed","h1 (passed)",10,0,10);
      TH1::AddDirectory(bStatus);
   }

   SetBit(kPosteriorMode,false);
   SetBit(kShortestInterval,false);

   SetStatisticOption(kDefStatOpt);
   SetDirectory(0);
}

//______________________________________________________________________________
TEfficiency::TEfficiency(const char* name,const char* title,Int_t nbins,
                         const Double_t* xbins):
fBeta_alpha(kDefBetaAlpha),
fBeta_beta(kDefBetaBeta),
fConfLevel(kDefConfLevel),
fDirectory(0),
fFunctions(0),
fPaintGraph(0),
fPaintHisto(0),
fWeight(kDefWeight)
{
   //create 1-dimensional TEfficiency object with variable bin size
   //
   //constructor creates two new and empty histograms with a given binning
   //
   // Input: name   - the common part of the name for both histograms (no blanks)
   //                 fTotalHistogram has name: name + "_total"
   //                 fPassedHistogram has name: name + "_passed"
   //        title  - the common part of the title for both histogram
   //                 fTotalHistogram has title: title + " (total)"
   //                 fPassedHistogram has title: title + " (passed)"
   //                 It is possible to label the axis by passing a title with
   //                 the following format: "title;xlabel;ylabel".
   //        nbins  - number of bins on the x-axis
   //        xbins  - array of length (nbins + 1) with low-edges for each bin
   //                 xbins[nbinsx] ... lower edge for overflow bin

   Bool_t bStatus = TH1::AddDirectoryStatus();
   TH1::AddDirectory(kFALSE);
   fTotalHistogram = new TH1D("total","total",nbins,xbins);
   fPassedHistogram = new TH1D("passed","passed",nbins,xbins);
   TH1::AddDirectory(bStatus);

   Build(name,title);
}

//______________________________________________________________________________
TEfficiency::TEfficiency(const char* name,const char* title,Int_t nbinsx,
                         Double_t xlow,Double_t xup):
fBeta_alpha(kDefBetaAlpha),
fBeta_beta(kDefBetaBeta),
fConfLevel(kDefConfLevel),
fDirectory(0),
fFunctions(0),
fPaintGraph(0),
fPaintHisto(0),
fWeight(kDefWeight)
{
   //create 1-dimensional TEfficiency object with fixed bins isze
   //
   //constructor creates two new and empty histograms with a fixed binning
   //
   // Input: name   - the common part of the name for both histograms(no blanks)
   //                 fTotalHistogram has name: name + "_total"
   //                 fPassedHistogram has name: name + "_passed"
   //        title  - the common part of the title for both histogram
   //                 fTotalHistogram has title: title + " (total)"
   //                 fPassedHistogram has title: title + " (passed)"
   //                 It is possible to label the axis by passing a title with
   //                 the following format: "title;xlabel;ylabel".
   //        nbinsx - number of bins on the x-axis
   //        xlow   - lower edge of first bin
   //        xup    - upper edge of last bin

   Bool_t bStatus = TH1::AddDirectoryStatus();
   TH1::AddDirectory(kFALSE);
   fTotalHistogram = new TH1D("total","total",nbinsx,xlow,xup);
   fPassedHistogram = new TH1D("passed","passed",nbinsx,xlow,xup);
   TH1::AddDirectory(bStatus);

   Build(name,title);
}

//______________________________________________________________________________
TEfficiency::TEfficiency(const char* name,const char* title,Int_t nbinsx,
                         Double_t xlow,Double_t xup,Int_t nbinsy,
                         Double_t ylow,Double_t yup):
fBeta_alpha(kDefBetaAlpha),
fBeta_beta(kDefBetaBeta),
fConfLevel(kDefConfLevel),
fDirectory(0),
fFunctions(0),
fPaintGraph(0),
fPaintHisto(0),
fWeight(kDefWeight)
{
   //create 2-dimensional TEfficiency object with fixed bin size
   //
   //constructor creates two new and empty histograms with a fixed binning
   //
   // Input: name   - the common part of the name for both histograms(no blanks)
   //                 fTotalHistogram has name: name + "_total"
   //                 fPassedHistogram has name: name + "_passed"
   //        title  - the common part of the title for both histogram
   //                 fTotalHistogram has title: title + " (total)"
   //                 fPassedHistogram has title: title + " (passed)"
   //                 It is possible to label the axis by passing a title with
   //                 the following format: "title;xlabel;ylabel;zlabel".
   //        nbinsx - number of bins on the x-axis
   //        xlow   - lower edge of first x-bin
   //        xup    - upper edge of last x-bin
   //        nbinsy - number of bins on the y-axis
   //        ylow   - lower edge of first y-bin
   //        yup    - upper edge of last y-bin

   Bool_t bStatus = TH1::AddDirectoryStatus();
   TH1::AddDirectory(kFALSE);
   fTotalHistogram = new TH2D("total","total",nbinsx,xlow,xup,nbinsy,ylow,yup);
   fPassedHistogram = new TH2D("passed","passed",nbinsx,xlow,xup,nbinsy,ylow,yup);
   TH1::AddDirectory(bStatus);

   Build(name,title);
}

//______________________________________________________________________________
TEfficiency::TEfficiency(const char* name,const char* title,Int_t nbinsx,
                         const Double_t* xbins,Int_t nbinsy,
                         const Double_t* ybins):
fBeta_alpha(kDefBetaAlpha),
fBeta_beta(kDefBetaBeta),
fConfLevel(kDefConfLevel),
fDirectory(0),
fFunctions(0),
fPaintGraph(0),
fPaintHisto(0),
fWeight(kDefWeight)
{
   //create 2-dimensional TEfficiency object with variable bin size
   //
   //constructor creates two new and empty histograms with a given binning
   //
   // Input: name   - the common part of the name for both histograms(no blanks)
   //                 fTotalHistogram has name: name + "_total"
   //                 fPassedHistogram has name: name + "_passed"
   //        title  - the common part of the title for both histogram
   //                 fTotalHistogram has title: title + " (total)"
   //                 fPassedHistogram has title: title + " (passed)"
   //                 It is possible to label the axis by passing a title with
   //                 the following format: "title;xlabel;ylabel;zlabel".
   //        nbinsx - number of bins on the x-axis
   //        xbins  - array of length (nbins + 1) with low-edges for each bin
   //                 xbins[nbinsx] ... lower edge for overflow x-bin
   //        nbinsy - number of bins on the y-axis
   //        ybins  - array of length (nbins + 1) with low-edges for each bin
   //                 ybins[nbinsy] ... lower edge for overflow y-bin

   Bool_t bStatus = TH1::AddDirectoryStatus();
   TH1::AddDirectory(kFALSE);
   fTotalHistogram = new TH2D("total","total",nbinsx,xbins,nbinsy,ybins);
   fPassedHistogram = new TH2D("passed","passed",nbinsx,xbins,nbinsy,ybins);
   TH1::AddDirectory(bStatus);

   Build(name,title);
}

//______________________________________________________________________________
TEfficiency::TEfficiency(const char* name,const char* title,Int_t nbinsx,
                         Double_t xlow,Double_t xup,Int_t nbinsy,
                         Double_t ylow,Double_t yup,Int_t nbinsz,
                         Double_t zlow,Double_t zup):
fBeta_alpha(kDefBetaAlpha),
fBeta_beta(kDefBetaBeta),
fConfLevel(kDefConfLevel),
fDirectory(0),
fFunctions(0),
fPaintGraph(0),
fPaintHisto(0),
fWeight(kDefWeight)
{
   //create 3-dimensional TEfficiency object with fixed bin size
   //
   //constructor creates two new and empty histograms with a fixed binning
   //
   // Input: name   - the common part of the name for both histograms(no blanks)
   //                 fTotalHistogram has name: name + "_total"
   //                 fPassedHistogram has name: name + "_passed"
   //        title  - the common part of the title for both histogram
   //                 fTotalHistogram has title: title + " (total)"
   //                 fPassedHistogram has title: title + " (passed)"
   //                 It is possible to label the axis by passing a title with
   //                 the following format: "title;xlabel;ylabel;zlabel".
   //        nbinsx - number of bins on the x-axis
   //        xlow   - lower edge of first x-bin
   //        xup    - upper edge of last x-bin
   //        nbinsy - number of bins on the y-axis
   //        ylow   - lower edge of first y-bin
   //        yup    - upper edge of last y-bin
   //        nbinsz - number of bins on the z-axis
   //        zlow   - lower edge of first z-bin
   //        zup    - upper edge of last z-bin

   Bool_t bStatus = TH1::AddDirectoryStatus();
   TH1::AddDirectory(kFALSE);
   fTotalHistogram = new TH3D("total","total",nbinsx,xlow,xup,nbinsy,ylow,yup,nbinsz,zlow,zup);
   fPassedHistogram = new TH3D("passed","passed",nbinsx,xlow,xup,nbinsy,ylow,yup,nbinsz,zlow,zup);
   TH1::AddDirectory(bStatus);

   Build(name,title);
}

//______________________________________________________________________________
TEfficiency::TEfficiency(const char* name,const char* title,Int_t nbinsx,
                         const Double_t* xbins,Int_t nbinsy,
                         const Double_t* ybins,Int_t nbinsz,
                         const Double_t* zbins):
fBeta_alpha(kDefBetaAlpha),
fBeta_beta(kDefBetaBeta),
fConfLevel(kDefConfLevel),
fDirectory(0),
fFunctions(0),
fPaintGraph(0),
fPaintHisto(0),
fWeight(kDefWeight)
{
   //create 3-dimensional TEfficiency object with variable bin size
   //
   //constructor creates two new and empty histograms with a given binning
   //
   // Input: name   - the common part of the name for both histograms(no blanks)
   //                 fTotalHistogram has name: name + "_total"
   //                 fPassedHistogram has name: name + "_passed"
   //        title  - the common part of the title for both histogram
   //                 fTotalHistogram has title: title + " (total)"
   //                 fPassedHistogram has title: title + " (passed)"
   //                 It is possible to label the axis by passing a title with
   //                 the following format: "title;xlabel;ylabel;zlabel".
   //        nbinsx - number of bins on the x-axis
   //        xbins  - array of length (nbins + 1) with low-edges for each bin
   //                 xbins[nbinsx] ... lower edge for overflow x-bin
   //        nbinsy - number of bins on the y-axis
   //        ybins  - array of length (nbins + 1) with low-edges for each bin
   //                 xbins[nbinsx] ... lower edge for overflow y-bin
   //        nbinsz - number of bins on the z-axis
   //        zbins  - array of length (nbins + 1) with low-edges for each bin
   //                 xbins[nbinsx] ... lower edge for overflow z-bin

   Bool_t bStatus = TH1::AddDirectoryStatus();
   TH1::AddDirectory(kFALSE);
   fTotalHistogram = new TH3D("total","total",nbinsx,xbins,nbinsy,ybins,nbinsz,zbins);
   fPassedHistogram = new TH3D("passed","passed",nbinsx,xbins,nbinsy,ybins,nbinsz,zbins);
   TH1::AddDirectory(bStatus);

   Build(name,title);
}

//______________________________________________________________________________
TEfficiency::TEfficiency(const TEfficiency& rEff):
TNamed(),
TAttLine(),
TAttFill(),
TAttMarker(),
fBeta_alpha(rEff.fBeta_alpha),
fBeta_beta(rEff.fBeta_beta),
fBeta_bin_params(rEff.fBeta_bin_params),
fConfLevel(rEff.fConfLevel),
fDirectory(0),
fFunctions(0),
fPaintGraph(0),
fPaintHisto(0),
fWeight(rEff.fWeight)
{
   //copy constructor
   //
   //The list of associated objects (e.g. fitted functions) is not copied.
   //
   //Note: - SetName(rEff.GetName() + "_copy") is called to set the names of the
   //        object and the histograms.
   //      - The titles are set by calling SetTitle("[copy] " + rEff.GetTitle()).
   //      - The copied TEfficiency object is NOT appended to a directory. It
   //        will not be written to disk during the next TFile::Write() command
   //        in order to prevent duplication of data. If you want to save this
   //        TEfficiency object anyway, you can either append it to a directory
   //        by calling SetDirectory(TDirectory*) or write it explicitly to disk
   //        by calling Write().

   // copy TObject bits
   ((TObject&)rEff).Copy(*this);

   Bool_t bStatus = TH1::AddDirectoryStatus();
   TH1::AddDirectory(kFALSE);
   fTotalHistogram = (TH1*)((rEff.fTotalHistogram)->Clone());
   fPassedHistogram = (TH1*)((rEff.fPassedHistogram)->Clone());
   TH1::AddDirectory(bStatus);

   TString name = rEff.GetName();
   name += "_copy";
   SetName(name);
   TString title = "[copy] ";
   title += rEff.GetTitle();
   SetTitle(title);

   SetStatisticOption(rEff.GetStatisticOption());

   SetDirectory(0);

   //copy style
   rEff.TAttLine::Copy(*this);
   rEff.TAttFill::Copy(*this);
   rEff.TAttMarker::Copy(*this);
}

//______________________________________________________________________________
TEfficiency::~TEfficiency()
{
   //default destructor

   //delete all function in fFunctions
   // use same logic as in TH1 destructor
   // (see TH1::~TH1 code in TH1.cxx)
   if(fFunctions) {
      fFunctions->SetBit(kInvalidObject);
      TObject* obj = 0;
      while ((obj  = fFunctions->First())) {
         while(fFunctions->Remove(obj)) { }
         if (!obj->TestBit(kNotDeleted)) {
            break;
         }
         delete obj;
         obj = 0;
      }
      delete fFunctions;
      fFunctions = 0;
   }

   if(fDirectory)
      fDirectory->Remove(this);

   delete fTotalHistogram;
   delete fPassedHistogram;
   delete fPaintGraph;
   delete fPaintHisto;
}

//______________________________________________________________________________
Double_t TEfficiency::AgrestiCoull(Int_t total,Int_t passed,Double_t level,Bool_t bUpper)
{
   //calculates the boundaries for the frequentist Agresti-Coull interval
   //
   //Input: - total : number of total events
   //       - passed: 0 <= number of passed events <= total
   //       - level : confidence level
   //       - bUpper: true  - upper boundary is returned
   //                 false - lower boundary is returned
   //
   //calculation:
   //Begin_Latex(separator='=',align='rl')
   // #alpha = 1 - #frac{level}{2}
   // #kappa = #Phi^{-1}(1 - #alpha,1) ... normal quantile function
   // mode = #frac{passed + #frac{#kappa^{2}}{2}}{total + #kappa^{2}}
   // #Delta = #kappa * #sqrt{#frac{mode * (1 - mode)}{total + #kappa^{2}}}
   // return =  max(0,mode - #Delta) or min(1,mode + #Delta)
   //End_Latex

   Double_t alpha = (1.0 - level)/2;
   Double_t kappa = ROOT::Math::normal_quantile(1 - alpha,1);

   Double_t mode = (passed + 0.5 * kappa * kappa) / (total + kappa * kappa);
   Double_t delta = kappa * std::sqrt(mode * (1 - mode) / (total + kappa * kappa));

   if(bUpper)
      return ((mode + delta) > 1) ? 1.0 : (mode + delta);
   else
      return ((mode - delta) < 0) ? 0.0 : (mode - delta);
}

//______________________________________________________________________________
Double_t TEfficiency::FeldmanCousins(Int_t total,Int_t passed,Double_t level,Bool_t bUpper)
{
   //calculates the boundaries for the frequentist Feldman-Cousins interval
   //
   //Input: - total : number of total events
   //       - passed: 0 <= number of passed events <= total
   //       - level : confidence level
   //       - bUpper: true  - upper boundary is returned
   //                 false - lower boundary is returned
   //
   //
   Double_t lower = 0;
   Double_t upper = 1;
   if (!FeldmanCousinsInterval(total,passed,level, lower, upper)) {
      ::Error("FeldmanCousins","Error running FC method - return 0 or 1");
   }
   return (bUpper) ? upper : lower;
}
Bool_t TEfficiency::FeldmanCousinsInterval(Int_t total,Int_t passed,Double_t level,Double_t & lower, Double_t & upper)
{
   //calculates the interval boundaries using the frequentist methods of Feldman-Cousins
   //
   //Input: - total : number of total events
   //       - passed: 0 <= number of passed events <= total
   //       - level : confidence level
   //Output:
   //       - lower :  lower boundary returned on exit
   //       - upper :  lower boundary returned on exit
   //
   //Return a flag with the status of the calculation
   //
   // Calculation:
   // The Feldman-Cousins is a frequentist method where the interval is estimated using a Neyman construction where the ordering
   // is based on the likelihood ratio:
   //Begin_Latex(separator='=',align='rl')
   // LR =  #frac{Binomial(k | N, #epsilon)}{Binomial(k | N, #hat{#epsilon} ) }
   //End_Latex
   //See G. J. Feldman and R. D. Cousins, Phys. Rev. D57 (1998) 3873
   // and   R. D. Cousins, K. E. Hymes, J. Tucker, Nuclear Instruments and Methods in Physics Research A 612 (2010) 388
   //
   // Implemented using classes developed by Jordan Tucker and Luca Lista
   // See File hist/hist/src/TEfficiencyHelper.h
   //
   FeldmanCousinsBinomialInterval fc;
   double alpha = 1.-level;
   fc.Init(alpha);
   fc.Calculate(passed, total);
   lower = fc.Lower();
   upper = fc.Upper();
   return true;
}

//______________________________________________________________________________
Double_t TEfficiency::Bayesian(Int_t total,Int_t passed,Double_t level,Double_t alpha,Double_t beta,Bool_t bUpper, Bool_t bShortest)
{
   //calculates the boundaries for a Bayesian confidence interval (shortest or central interval depending on the option)
   //
   //Input: - total : number of total events
   //       - passed: 0 <= number of passed events <= total
   //       - level : confidence level
   //       - alpha : shape parameter > 0 for the prior distribution (fBeta_alpha)
   //       - beta  : shape parameter > 0 for the prior distribution (fBeta_beta)
   //       - bUpper: true  - upper boundary is returned
   //                 false - lower boundary is returned
   //
   //Note: In the case central confidence interval is calculated.
   //      when passed = 0 (or passed = total) the lower (or upper)
   //      interval values will be larger than 0 (or smaller than 1).
   //
   //Calculation:
   //
   //The posterior probability in bayesian statistics is given by:
   //Begin_Latex P(#varepsilon |k,N) #propto L(#varepsilon|k,N) #times Prior(#varepsilon)End_Latex
   //As an efficiency can be interpreted as probability of a positive outcome of
   //a Bernoullli trial the likelihood function is given by the binomial
   //distribution:
   //Begin_Latex L(#varepsilon|k,N) = Binomial(N,k) #varepsilon ^{k} (1 - #varepsilon)^{N-k}End_Latex
   //At the moment only beta distributions are supported as prior probabilities
   //of the efficiency (Begin_Latex #scale[0.8]{B(#alpha,#beta)}End_Latex is the beta function):
   //Begin_Latex Prior(#varepsilon) = #frac{1}{B(#alpha,#beta)} #varepsilon ^{#alpha - 1} (1 - #varepsilon)^{#beta - 1}End_Latex
   //The posterior probability is therefore again given by a beta distribution:
   //Begin_Latex P(#varepsilon |k,N) #propto #varepsilon ^{k + #alpha - 1} (1 - #varepsilon)^{N - k + #beta - 1} End_Latex
   //In case of central intervals
   //the lower boundary for the equal-tailed confidence interval is given by the
   //inverse cumulative (= quantile) function for the quantile Begin_Latex #frac{1 - level}{2} End_Latex.
   //The upper boundary for the equal-tailed confidence interval is given by the
   //inverse cumulative (= quantile) function for the quantile Begin_Latex #frac{1 + level}{2} End_Latex.
   //Hence it is the solution Begin_Latex #varepsilon End_Latex of the following equation:
   //Begin_Latex I_{#varepsilon}(k + #alpha,N - k + #beta) = #frac{1}{norm} #int_{0}^{#varepsilon} dt t^{k + #alpha - 1} (1 - t)^{N - k + #beta - 1} =  #frac{1 #pm level}{2} End_Latex
   // In the case of shortest interval the minimum interval aorund the mode is found by minimizing the length of all intervals whith the
   // given probability content. See TEfficiency::BetaShortestInterval

   Double_t a = double(passed)+alpha;
   Double_t b = double(total-passed)+beta;

   if (bShortest) {
      double lower = 0;
      double upper = 1;
      BetaShortestInterval(level,a,b,lower,upper);
      return (bUpper) ? upper : lower;
   }
   else
      return BetaCentralInterval(level, a, b, bUpper);
}
//______________________________________________________________________________
Double_t TEfficiency::BetaCentralInterval(Double_t level,Double_t a,Double_t b,Bool_t bUpper)
{
   //calculates the boundaries for a central confidence interval for a Beta distribution
   //
   //Input: - level : confidence level
   //       -    a  : parameter > 0 for the beta distribution (for a posterior is passed + prior_alpha
   //       -    b  : parameter > 0 for the beta distribution (for a posterior is (total-passed) + prior_beta
   //       - bUpper: true  - upper boundary is returned
   //                 false - lower boundary is returned
   //

   if(bUpper) {
      if((a > 0) && (b > 0))
         return ROOT::Math::beta_quantile((1+level)/2,a,b);
      else {
         gROOT->Error("TEfficiency::BayesianCentral","Invalid input parameters - return 1");
         return 1;
      }
   }
   else {
      if((a > 0) && (b > 0))
         return ROOT::Math::beta_quantile((1-level)/2,a,b);
      else {
         gROOT->Error("TEfficiency::BayesianCentral","Invalid input parameters - return 0");
         return 0;
      }
   }
}

struct Beta_interval_length {
   Beta_interval_length(Double_t level,Double_t alpha,Double_t beta ) :
   fCL(level), fAlpha(alpha), fBeta(beta)
   {}

   Double_t LowerMax() {
      // max allowed value of lower given the interval size
      return ROOT::Math::beta_quantile_c(fCL, fAlpha,fBeta);
   }

   Double_t operator() (double lower) const {
      // return length of interval
      Double_t plow = ROOT::Math::beta_cdf(lower, fAlpha, fBeta);
      Double_t pup = plow + fCL;
      double upper = ROOT::Math::beta_quantile(pup, fAlpha,fBeta);
      return upper-lower;
   }
   Double_t fCL; // interval size (confidence level)
   Double_t fAlpha; // beta distribution alpha parameter
   Double_t fBeta; // beta distribution beta parameter

};

//______________________________________________________________________________
Bool_t TEfficiency::BetaShortestInterval(Double_t level,Double_t a,Double_t b, Double_t & lower, Double_t & upper)
{
   //calculates the boundaries for a shortest confidence interval for a Beta  distribution
   //
   //Input: - level : confidence level
   //       -    a  : parameter > 0 for the beta distribution (for a posterior is passed + prior_alpha
   //       -    b  : parameter > 0 for the beta distribution (for a posterior is (total-passed) + prior_beta
   //       - bUpper: true  - upper boundary is returned
   //                 false - lower boundary is returned
   //
   //
   //The lower/upper boundary are then obtained by finding the shortest interval of the beta distribbution
   // contained the desired probability level.
   // The length of all possible intervals is minimized in order to find the shortest one

   if (a <= 0 || b <= 0) {
      lower = 0; upper = 1;
      gROOT->Error("TEfficiency::BayesianShortest","Invalid input parameters - return [0,1]");
      return kFALSE;
   }

   // treat here special cases when mode == 0 or 1
   double mode = BetaMode(a,b);
   if (mode == 0.0) {
      lower = 0;
      upper = ROOT::Math::beta_quantile(level, a, b);
      return kTRUE;
   }
   if (mode == 1.0) {
      lower = ROOT::Math::beta_quantile_c(level, a, b);
      upper = 1.0;
      return kTRUE;
   }
   // special case when the shortest interval is undefined  return the central interval
   // can happen for a posterior when passed=total=0
   //
   if ( a==b && a<=1.0) {
      lower = BetaCentralInterval(level,a,b,kFALSE);
      upper = BetaCentralInterval(level,a,b,kTRUE);
      return kTRUE;
   }

   // for the other case perform a minimization
   // make a function of the length of the posterior interval as a function of lower bound
   Beta_interval_length intervalLength(level,a,b);
   // minimize the interval length
   ROOT::Math::WrappedFunction<const Beta_interval_length &> func(intervalLength);
   ROOT::Math::BrentMinimizer1D minim;
   minim.SetFunction(func, 0, intervalLength.LowerMax() );
   minim.SetNpx(2); // no need to bracket with many iterations. Just do few times to estimate some better points
   bool ret = minim.Minimize(100, 1.E-10,1.E-10);
   if (!ret) {
      gROOT->Error("TEfficiency::BayesianShortes","Error finding the shortest interval");
      return kFALSE;
   }
   lower = minim.XMinimum();
   upper = lower + minim.FValMinimum();
   return kTRUE;
}

//______________________________________________________________________________
Double_t TEfficiency::BetaMean(Double_t a,Double_t b)
{
   // compute the mean (average) of the beta distribution
   //
   //Input:    a  : parameter > 0 for the beta distribution (for a posterior is passed + prior_alpha
   //          b  : parameter > 0 for the beta distribution (for a posterior is (total-passed) + prior_beta
   //

   if (a <= 0 || b <= 0 ) {
      gROOT->Error("TEfficiency::BayesianMean","Invalid input parameters - return 0");
      return 0;
   }

   Double_t mean =  a / (a + b);
   return mean;
}

//______________________________________________________________________________
Double_t TEfficiency::BetaMode(Double_t a,Double_t b)
{
   // compute the mode of the beta distribution
   //
   //Input:    a  : parameter > 0 for the beta distribution (for a posterior is passed + prior_alpha
   //          b  : parameter > 0 for the beta distribution (for a posterior is (total-passed) + prior_beta
   //
   // note the mode is defined for a Beta(a,b) only if (a,b)>1 (a = passed+alpha; b = total-passed+beta)
   // return then the following in case (a,b) < 1:
   //  if (a==b) return 0.5 (it is really undefined)
   //  if (a < b) return 0;
   //  if (a > b) return 1;

   if (a <= 0 || b <= 0 ) {
      gROOT->Error("TEfficiency::BayesianMode","Invalid input parameters - return 0");
      return 0;
   }
   if ( a <= 1 || b <= 1) {
      if ( a < b) return 0;
      if ( a > b) return 1;
      if (a == b) return 0.5; // cannot do otherwise
   }

   // since a and b are > 1 here denominator cannot be 0 or < 0
   Double_t mode =  (a - 1.0) / (a + b -2.0);
   return mode;
}
//______________________________________________________________________________
void TEfficiency::Build(const char* name,const char* title)
{
   //building standard data structure of a TEfficiency object
   //
   //Notes: - calls: SetName(name), SetTitle(title)
   //       - set the statistic option to the default (kFCP)
   //       - appends this object to the current directory
   //         SetDirectory(gDirectory)

   SetName(name);
   SetTitle(title);

   SetStatisticOption(kDefStatOpt);
   SetDirectory(gDirectory);

   SetBit(kPosteriorMode,false);
   SetBit(kShortestInterval,false);
   SetBit(kUseWeights,false);

   //set normalisation factors to 0, otherwise the += may not work properly
   fPassedHistogram->SetNormFactor(0);
   fTotalHistogram->SetNormFactor(0);
}

//______________________________________________________________________________
Bool_t TEfficiency::CheckBinning(const TH1& pass,const TH1& total)
{
   //checks binning for each axis
   //
   //It is assumed that the passed histograms have the same dimension.

   TAxis* ax1 = 0;
   TAxis* ax2 = 0;

   //check binning along axis
   for(Int_t j = 0; j < pass.GetDimension(); ++j) {
      switch(j) {
         case 0:
            ax1 = pass.GetXaxis();
            ax2 = total.GetXaxis();
            break;
         case 1:
            ax1 = pass.GetYaxis();
            ax2 = total.GetYaxis();
            break;
         case 2:
            ax1 = pass.GetZaxis();
            ax2 = total.GetZaxis();
            break;
      }

      if(ax1->GetNbins() != ax2->GetNbins()) {
         gROOT->Info("TEfficiency::CheckBinning","Histograms are not consistent: they have different number of bins");
         return false;
      }

      for(Int_t i = 1; i <= ax1->GetNbins() + 1; ++i)
         if(!TMath::AreEqualRel(ax1->GetBinLowEdge(i), ax2->GetBinLowEdge(i), 1.E-15)) {
            gROOT->Info("TEfficiency::CheckBinning","Histograms are not consistent: they have different bin edges");
            return false;
         }

      if(!TMath::AreEqualRel(ax1->GetXmax(), ax2->GetXmax(), 1.E-15)) {
         gROOT->Info("TEfficiency::CheckBinning","Histograms are not consistent: they have different axis max value");
         return false;
      }


   }

   return true;
}

//______________________________________________________________________________
Bool_t TEfficiency::CheckConsistency(const TH1& pass,const TH1& total,Option_t* opt)
{
   //checks the consistence of the given histograms
   //
   //The histograms are considered as consistent if:
   //- both have the same dimension
   //- both have the same binning
   //- pass.GetBinContent(i) <= total.GetBinContent(i) for each bin i
   //
   //Option: - w: The check for unit weights is skipped and therefore histograms
   //             filled with weights are accepted.

   if(pass.GetDimension() != total.GetDimension()) {
      gROOT->Error("TEfficiency::CheckConsistency","passed TEfficiency objects have different dimensions");
      return false;
   }

   if(!CheckBinning(pass,total)) {
      gROOT->Error("TEfficiency::CheckConsistency","passed TEfficiency objects have different binning");
      return false;
   }

   if(!CheckEntries(pass,total,opt)) {
      gROOT->Error("TEfficiency::CheckConsistency","passed TEfficiency objects do not have consistent bin contents");
      return false;
   }

   return true;
}

//______________________________________________________________________________
Bool_t TEfficiency::CheckEntries(const TH1& pass,const TH1& total,Option_t* opt)
{
   //checks whether bin contents are compatible with binomial statistics
   //
   //The following inequality has to be valid for each bin i:
   // total.GetBinContent(i) >= pass.GetBinContent(i)
   //
   //and the histogram have to be filled with unit weights.
   //
   //Option: - w: Do not check for unit weights -> accept histograms filled with
   //             weights
   //
   //Note: - It is assumed that both histograms have the same dimension and
   //        binning.

   TString option = opt;
   option.ToLower();

   //check for unit weights
   if(!option.Contains("w")) {
      Double_t statpass[TH1::kNstat];
      Double_t stattotal[TH1::kNstat];

      pass.GetStats(statpass);
      total.GetStats(stattotal);

      //require: sum of weights == sum of weights^2
      if((TMath::Abs(statpass[0]-statpass[1]) > 1e-5) ||
         (TMath::Abs(stattotal[0]-stattotal[1]) > 1e-5)) {
         gROOT->Info("TEfficiency::CheckEntries","Histograms are filled with weights");
         return false;
      }
   }

   //check: pass <= total
   Int_t nbinsx, nbinsy, nbinsz, nbins;

   nbinsx = pass.GetNbinsX();
   nbinsy = pass.GetNbinsY();
   nbinsz = pass.GetNbinsZ();

   switch(pass.GetDimension()) {
      case 1: nbins = nbinsx + 2; break;
      case 2: nbins = (nbinsx + 2) * (nbinsy + 2); break;
      case 3: nbins = (nbinsx + 2) * (nbinsy + 2) * (nbinsz + 2); break;
      default: nbins = 0;
   }

   for(Int_t i = 0; i < nbins; ++i) {
      if(pass.GetBinContent(i) > total.GetBinContent(i)) {
         gROOT->Info("TEfficiency::CheckEntries","Histograms are not consistent: passed bin content > total bin content");
         return false;
      }
   }

   return true;
}

//______________________________________________________________________________
TGraphAsymmErrors * TEfficiency::CreateGraph(Option_t * opt) const
{
   // Create the graph used be painted (for dim=1 TEfficiency)
   // The return object is managed by the caller

   if (GetDimension() != 1) {
      Error("CreatePaintingGraph","Call this function only for dimension == 1");
      return 0;
   }


   Int_t npoints = fTotalHistogram->GetNbinsX();
   TGraphAsymmErrors * graph = new TGraphAsymmErrors(npoints);
   graph->SetName("eff_graph");
   FillGraph(graph,opt);

   return graph;
}


//______________________________________________________________________________
void TEfficiency::FillGraph(TGraphAsymmErrors * graph, Option_t * opt) const
{
   // Fill the graph to be painted with information from TEfficiency
   // Internal metyhod called by TEfficiency::Paint or TEfficiency::CreateGraph

   TString option = opt;
   option.ToLower();

   Bool_t plot0Bins = false;
   if (option.Contains("e0") ) plot0Bins = true;

   Double_t x,y,xlow,xup,ylow,yup;
   //point i corresponds to bin i+1 in histogram
   // point j is point graph index
   // LM: cannot use TGraph::SetPoint because it deletes the underlying
   // histogram  each time (see TGraph::SetPoint)
   // so use it only when extra points are added to the graph
   Int_t j = 0;
   double * px = graph->GetX();
   double * py = graph->GetY();
   double * exl = graph->GetEXlow();
   double * exh = graph->GetEXhigh();
   double * eyl = graph->GetEYlow();
   double * eyh = graph->GetEYhigh();
   Int_t npoints = fTotalHistogram->GetNbinsX();
   for (Int_t i = 0; i < npoints; ++i) {
      if (!plot0Bins && fTotalHistogram->GetBinContent(i+1) == 0 )    continue;
      x = fTotalHistogram->GetBinCenter(i+1);
      y = GetEfficiency(i+1);
      xlow = fTotalHistogram->GetBinCenter(i+1) - fTotalHistogram->GetBinLowEdge(i+1);
      xup = fTotalHistogram->GetBinWidth(i+1) - xlow;
      ylow = GetEfficiencyErrorLow(i+1);
      yup = GetEfficiencyErrorUp(i+1);
      // in the case the graph already existed and extra points have been added
      if (j >= graph->GetN() ) {
         graph->SetPoint(j,x,y);
         graph->SetPointError(j,xlow,xup,ylow,yup);
      }
      else {
         px[j] = x;
         py[j] = y;
         exl[j] = xlow;
         exh[j] = xup;
         eyl[j] = ylow;
         eyh[j] = yup;
      }
      j++;
   }

   // tell the graph the effective number of points
   graph->Set(j);
   //refresh title before painting if changed
   TString oldTitle = graph->GetTitle();
   TString newTitle = GetTitle();
   if (oldTitle != newTitle ) {
      graph->SetTitle(newTitle);
   }

   // set the axis labels
   TString xlabel = fTotalHistogram->GetXaxis()->GetTitle();
   TString ylabel = fTotalHistogram->GetYaxis()->GetTitle();
   if (xlabel) graph->GetXaxis()->SetTitle(xlabel);
   if (ylabel) graph->GetYaxis()->SetTitle(ylabel);

   //copying style information
   TAttLine::Copy(*graph);
   TAttFill::Copy(*graph);
   TAttMarker::Copy(*graph);

   // this method forces the graph to compute correctly the axis
   // according to the given points
   graph->GetHistogram();

}

//______________________________________________________________________________
TH2 * TEfficiency::CreateHistogram(Option_t *) const
{
   // Create the histogram used to be painted (for dim=2 TEfficiency)
   // The return object is managed by the caller

   if (GetDimension() != 2) {
      Error("CreatePaintingistogram","Call this function only for dimension == 2");
      return 0;
   }

   Int_t nbinsx = fTotalHistogram->GetNbinsX();
   Int_t nbinsy = fTotalHistogram->GetNbinsY();
   TAxis * xaxis = fTotalHistogram->GetXaxis();
   TAxis * yaxis = fTotalHistogram->GetYaxis();
   TH2 * hist = 0;

   if (xaxis->IsVariableBinSize() && yaxis->IsVariableBinSize() )
      hist = new TH2F("eff_histo",GetTitle(),nbinsx,xaxis->GetXbins()->GetArray(),
                      nbinsy,yaxis->GetXbins()->GetArray());
   else if (xaxis->IsVariableBinSize() && ! yaxis->IsVariableBinSize() )
      hist = new TH2F("eff_histo",GetTitle(),nbinsx,xaxis->GetXbins()->GetArray(),
                      nbinsy,yaxis->GetXmin(), yaxis->GetXmax());
   else if (!xaxis->IsVariableBinSize() &&  yaxis->IsVariableBinSize() )
      hist = new TH2F("eff_histo",GetTitle(),nbinsx,xaxis->GetXmin(), xaxis->GetXmax(),
                      nbinsy,yaxis->GetXbins()->GetArray());
   else
      hist = new TH2F("eff_histo",GetTitle(),nbinsx,xaxis->GetXmin(), xaxis->GetXmax(),
                      nbinsy,yaxis->GetXmin(), yaxis->GetXmax());


   hist->SetDirectory(0);

   FillHistogram(hist);

   return hist;
}

//______________________________________________________________________________
void TEfficiency::FillHistogram(TH2 * hist ) const
{
   // Fill the 2d histogram to be painted with information from TEfficiency 2D
   // Internal metyhod called by TEfficiency::Paint or TEfficiency::CreatePaintingGraph

   //refresh title before each painting
   hist->SetTitle(GetTitle());

   // set the axis labels
   TString xlabel = fTotalHistogram->GetXaxis()->GetTitle();
   TString ylabel = fTotalHistogram->GetYaxis()->GetTitle();
   if (xlabel) hist->GetXaxis()->SetTitle(xlabel);
   if (ylabel) hist->GetYaxis()->SetTitle(ylabel);

   Int_t bin;
   Int_t nbinsx = hist->GetNbinsX();
   Int_t nbinsy = hist->GetNbinsY();
   for(Int_t i = 0; i < nbinsx + 2; ++i) {
      for(Int_t j = 0; j < nbinsy + 2; ++j) {
         bin = GetGlobalBin(i,j);
         hist->SetBinContent(bin,GetEfficiency(bin));
      }
   }

   //copying style information
   TAttLine::Copy(*hist);
   TAttFill::Copy(*hist);
   TAttMarker::Copy(*hist);
   hist->SetStats(0);

   return;

}
//______________________________________________________________________________
Double_t TEfficiency::ClopperPearson(Int_t total,Int_t passed,Double_t level,Bool_t bUpper)
{
   //calculates the boundaries for the frequentist Clopper-Pearson interval
   //
   //This interval is recommended by the PDG.
   //
   //Input: - total : number of total events
   //       - passed: 0 <= number of passed events <= total
   //       - level : confidence level
   //       - bUpper: true  - upper boundary is returned
   //                 false - lower boundary is returned
   //
   //calculation:
   //
   //The lower boundary of the Clopper-Pearson interval is the "exact" inversion
   //of the test:
   //Begin_Latex(separator='=',align='rl')
   //P(x #geq passed; total) = #frac{1 - level}{2}
   //P(x #geq passed; total) = 1 - P(x #leq passed - 1; total)
   // = 1 - #frac{1}{norm} * #int_{0}^{1 - #varepsilon} t^{total - passed} (1 - t)^{passed - 1} dt
   // = 1 - #frac{1}{norm} * #int_{#varepsilon}^{1} t^{passed - 1} (1 - t)^{total - passed} dt
   // = #frac{1}{norm} * #int_{0}^{#varepsilon} t^{passed - 1} (1 - t)^{total - passed} dt
   // = I_{#varepsilon}(passed,total - passed + 1)
   //End_Latex
   //The lower boundary is therfore given by the Begin_Latex #frac{1 - level}{2}End_Latex quantile
   //of the beta distribution.
   //
   //The upper boundary of the Clopper-Pearson interval is the "exact" inversion
   //of the test:
   //Begin_Latex(separator='=',align='rl')
   //P(x #leq passed; total) = #frac{1 - level}{2}
   //P(x #leq passed; total) = #frac{1}{norm} * #int_{0}^{1 - #varepsilon} t^{total - passed - 1} (1 - t)^{passed} dt
   // = #frac{1}{norm} * #int_{#varepsilon}^{1} t^{passed} (1 - t)^{total - passed - 1} dt
   // = 1 - #frac{1}{norm} * #int_{0}^{#varepsilon} t^{passed} (1 - t)^{total - passed - 1} dt
   // #Rightarrow 1 - #frac{1 - level}{2} = #frac{1}{norm} * #int_{0}^{#varepsilon} t^{passed} (1 - t)^{total - passed -1} dt
   // #frac{1 + level}{2} = I_{#varepsilon}(passed + 1,total - passed)
   //End_Latex
   //The upper boundary is therfore given by the Begin_Latex #frac{1 + level}{2}End_Latex quantile
   //of the beta distribution.
   //
   //Note: The connection between the binomial distribution and the regularized
   //      incomplete beta function Begin_Latex I_{#varepsilon}(#alpha,#beta)End_Latex has been used.

   Double_t alpha = (1.0 - level) / 2;
   if(bUpper)
      return ((passed == total) ? 1.0 : ROOT::Math::beta_quantile(1 - alpha,passed + 1,total-passed));
   else
      return ((passed == 0) ? 0.0 : ROOT::Math::beta_quantile(alpha,passed,total-passed+1.0));
}
//______________________________________________________________________________
Double_t TEfficiency::Combine(Double_t& up,Double_t& low,Int_t n,
                              const Int_t* pass,const Int_t* total,
                              Double_t alpha, Double_t beta,
                              Double_t level,const Double_t* w,Option_t* opt)
{
   //calculates the combined efficiency and its uncertainties
   //
   //This method does a bayesian combination of the given samples.
   //
   //Input:
   //- up     : contains the upper limit of the confidence interval afterwards
   //- low    : contains the lower limit of the confidence interval afterwards
   //- n      : number of samples which are combined
   //- pass   : array of length n containing the number of passed events
   //- total  : array of length n containing the corresponding numbers of total
   //           events
   //- alpha  : shape parameters for the beta distribution as prior
   //- beta   : shape parameters for the beta distribution as prior
   //- level  : desired confidence level
   //- w      : weights for each sample; if not given, all samples get the weight 1
   //           The weights do not need to be normalized, since they are internally renormalized
   //           to the number of effective entries.
   //- options:
   //
   // + mode : The mode is returned instead of the mean of the posterior as best value
   //          When using the mode the shortest interval is also computed instead of the central one
   // + shortest: compute shortest interval (done by default if mode option is set)
   // + central: compute central interval (done by default if mode option is NOT set)
   //
   //Begin_Html
   //Calculation:
   //<ol>
   //<li>The combined posterior distributions is calculated from the Bayes theorem assuming a common prior Beta distribution.
   //     It is easy to proof that the combined posterior is then:</li>
   //Begin_Latex(separator='=',align='rl')
   //P_{comb}(#epsilon |{w_{i}}; {k_{i}}; {N_{i}}) = B(#epsilon, #sum_{i}{ w_{i} k_{i}} + #alpha, #sum_{i}{ w_{i}(n_{i}-k_{i})}+#beta)
   //w_{i} = weight for each sample renormalized to the effective entries
   //w^{'}_{i} =  w_{i} #frac{ #sum_{i} {w_{i} } } { #sum_{i} {w_{i}^{2} } }
   //End_Latex
   //Begin_Html
   //<li>The estimated efficiency is the mode (or the mean) of the obtained posterior distribution </li>
   //End_Html
   //Begin_Html
   //<li>The boundaries of the confidence interval for a confidence level (1 - a)
   //are given by the a/2 and 1-a/2 quantiles of the resulting cumulative
   //distribution.</li>
   //</ol>
   //End_Html
   //Example (uniform prior distribution):
   //Begin_Macro(source)
   //{
   //  TCanvas* c1 = new TCanvas("c1","",600,800);
   //  c1->Divide(1,2);
   //  c1->SetFillStyle(1001);
   //  c1->SetFillColor(kWhite);
   //
   //  TF1* p1 = new TF1("p1","TMath::BetaDist(x,19,9)",0,1);
   //  TF1* p2 = new TF1("p2","TMath::BetaDist(x,4,8)",0,1);
   //  TF1* comb = new TF1("comb2","TMath::BetaDist(x,[0],[1])",0,1);
   //  double norm = 1./(0.6*0.6+0.4*0.4); // weight normalization
   //  double a = 0.6*18.0 + 0.4*3.0 + 1.0;  // new alpha parameter of combined beta dist.
   //  double b = 0.6*10+0.4*7+1.0;  // new beta parameter of combined beta dist.
   //  comb->SetParameters(norm*a ,norm *b );
   //  TF1* const1 = new TF1("const1","0.05",0,1);
   //  TF1* const2 = new TF1("const2","0.95",0,1);
   //
   //  p1->SetLineColor(kRed);
   //  p1->SetTitle("combined posteriors;#epsilon;P(#epsilon|k,N)");
   //  p2->SetLineColor(kBlue);
   //  comb->SetLineColor(kGreen+2);
   //
   //  TLegend* leg1 = new TLegend(0.12,0.65,0.5,0.85);
   //  leg1->AddEntry(p1,"k1 = 18, N1 = 26","l");
   //  leg1->AddEntry(p2,"k2 = 3, N2 = 10","l");
   //  leg1->AddEntry(comb,"combined: p1 = 0.6, p2=0.4","l");
   //
   //  c1->cd(1);
   //  comb->Draw();
   //  p1->Draw("same");
   //  p2->Draw("same");
   //  leg1->Draw("same");
   //  c1->cd(2);
   //  const1->SetLineWidth(1);
   //  const2->SetLineWidth(1);
   //  TGraph* gr = (TGraph*)comb->DrawIntegral();
   //  gr->SetTitle("cumulative function of combined posterior with boundaries for cl = 95%;#epsilon;CDF");
   //  const1->Draw("same");
   //  const2->Draw("same");
   //
   //  c1->cd(0);
   //  return c1;
   //}
   //End_Macro

   TString option(opt);
   option.ToLower();

   //LM:  new formula for combination
   // works only if alpha beta are the same always
   // the weights are normalized to w(i) -> N_eff w(i)/ Sum w(i)
   // i.e. w(i) -> Sum (w(i) / Sum (w(i)^2) * w(i)
   // norm = Sum (w(i) / Sum (w(i)^2)
   double ntot = 0;
   double ktot = 0;
   double sumw = 0;
   double sumw2 = 0;
   for (int i = 0; i < n ; ++i) {
      if(pass[i] > total[i]) {
         ::Error("TEfficiency::Combine","total events = %i < passed events %i",total[i],pass[i]);
         ::Info("TEfficiency::Combine","stop combining");
         return -1;
      }

      ntot += w[i] * total[i];
      ktot += w[i] * pass[i];
      sumw += w[i];
      sumw2 += w[i]*w[i];
      //mean += w[i] * (pass[i] + alpha[i])/(total[i] + alpha[i] + beta[i]);
   }
   double norm = sumw/sumw2;
   ntot *= norm;
   ktot *= norm;
   if(ktot > ntot) {
      ::Error("TEfficiency::Combine","total  = %f < passed  %f",ntot,ktot);
      ::Info("TEfficiency::Combine","stop combining");
      return -1;
   }

   double a = ktot + alpha;
   double b = ntot - ktot + beta;

   double mean = a/(a+b);
   double mode = BetaMode(a,b);


   Bool_t shortestInterval = option.Contains("sh") || ( option.Contains("mode") && !option.Contains("cent") );

   if (shortestInterval)
      BetaShortestInterval(level, a, b, low, up);
   else {
      low = BetaCentralInterval(level, a, b, false);
      up = BetaCentralInterval(level, a, b, true);
   }

   if (option.Contains("mode")) return mode;
   return mean;

}
//______________________________________________________________________________
TGraphAsymmErrors* TEfficiency::Combine(TCollection* pList,Option_t* option,
                                        Int_t n,const Double_t* w)
{
   //combines a list of 1-dimensional TEfficiency objects
   //
   //A TGraphAsymmErrors object is returned which contains the estimated
   //efficiency and its uncertainty for each bin.
   //If the combination fails, a zero pointer is returned.
   //
   //At the moment the combining is only implemented for bayesian statistics.
   //
   //Input:
   //- pList  : list containing TEfficiency objects which should be combined
   //           only one-dimensional efficiencies are taken into account
   //- options
   // + s     : strict combining; only TEfficiency objects with the same beta
   //           prior and the flag kIsBayesian == true are combined
   //           If not specified the prior parameter of the first TEfficiency object is used
   // + v     : verbose mode; print information about combining
   // + cl=x  : set confidence level (0 < cl < 1). If not specified, the
   //           confidence level of the first TEfficiency object is used.
   // + mode    Use mode of combined posterior as estimated value for the efficiency
   // + shortest: compute shortest interval (done by default if mode option is set)
   // + central: compute central interval (done by default if mode option is NOT set)
   //
   //- n      : number of weights (has to be the number of one-dimensional
   //           TEfficiency objects in pList)
   //           If no weights are passed, the internal weights GetWeight() of
   //           the given TEfficiency objects are used.
   //- w      : array of length n with weights for each TEfficiency object in
   //           pList (w[0] correspond to pList->First ... w[n-1] -> pList->Last)
   //           The weights do not have to be normalised.
   //
   //For each bin the calculation is done by the Combine(double&, double& ...) method.

   TString opt = option;
   opt.ToLower();

   //parameter of prior distribution, confidence level and normalisation factor
   Double_t alpha = -1;
   Double_t beta = -1;
   Double_t level = 0;

   //flags for combining
   Bool_t bStrict = false;
   Bool_t bOutput = false;
   Bool_t bWeights = false;
   //list of all information needed to weight and combine efficiencies
   std::vector<TH1*> vTotal;    vTotal.reserve(n);
   std::vector<TH1*> vPassed;   vPassed.reserve(n);
   std::vector<Double_t> vWeights;  vWeights.reserve(n);
   //    std::vector<Double_t> vAlpha;
   //    std::vector<Double_t> vBeta;

   if(opt.Contains("s")) {
      opt.ReplaceAll("s","");
      bStrict = true;
   }

   if(opt.Contains("v")) {
      opt.ReplaceAll("v","");
      bOutput = true;
   }

   if(opt.Contains("cl=")) {
      Ssiz_t pos = opt.Index("cl=") + 3;
      level = atof( opt(pos,opt.Length() ).Data() );
      if((level <= 0) || (level >= 1))
         level = 0;
      opt.ReplaceAll("cl=","");
   }

   //are weights explicitly given
   if(n && w) {
      bWeights = true;
      for(Int_t k = 0; k < n; ++k) {
         if(w[k] > 0)
            vWeights.push_back(w[k]);
         else {
            gROOT->Error("TEfficiency::Combine","invalid custom weight found w = %.2lf",w[k]);
            gROOT->Info("TEfficiency::Combine","stop combining");
            return 0;
         }
      }
   }

   TIter next(pList);
   TObject* obj = 0;
   TEfficiency* pEff = 0;
   while((obj = next())) {
      pEff = dynamic_cast<TEfficiency*>(obj);
      //is object a TEfficiency object?
      if(pEff) {
         if(pEff->GetDimension() > 1)
            continue;
         if(!level) level = pEff->GetConfidenceLevel();

         if(alpha<1) alpha = pEff->GetBetaAlpha();
         if(beta<1) beta = pEff->GetBetaBeta();

         //if strict combining, check priors, confidence level and statistic
         if(bStrict) {
            if(alpha != pEff->GetBetaAlpha())
               continue;
            if(beta != pEff->GetBetaBeta())
               continue;
            if(!pEff->UsesBayesianStat())
               continue;
         }

         vTotal.push_back(pEff->fTotalHistogram);
         vPassed.push_back(pEff->fPassedHistogram);

         //no weights given -> use weights of TEfficiency objects
         if(!bWeights)
            vWeights.push_back(pEff->fWeight);

         //strict combining -> using global prior
         //   if(bStrict) {
         //      vAlpha.push_back(alpha);
         //      vBeta.push_back(beta);
         //   }
         //   else {
         //      vAlpha.push_back(pEff->GetBetaAlpha());
         //      vBeta.push_back(pEff->GetBetaBeta());
         //   }
      }
   }

   //no TEfficiency objects found
   if(vTotal.empty()) {
      gROOT->Error("TEfficiency::Combine","no TEfficiency objects in given list");
      gROOT->Info("TEfficiency::Combine","stop combining");
      return 0;
   }

   //invalid number of custom weights
   if(bWeights && (n != (Int_t)vTotal.size())) {
      gROOT->Error("TEfficiency::Combine","number of weights n=%i differs from number of TEfficiency objects k=%i which should be combined",n,(Int_t)vTotal.size());
      gROOT->Info("TEfficiency::Combine","stop combining");
      return 0;
   }

   Int_t nbins_max = vTotal.at(0)->GetNbinsX();
   //check binning of all histograms
   for(UInt_t i=0; i<vTotal.size(); ++i) {
      if (!TEfficiency::CheckBinning(*vTotal.at(0),*vTotal.at(i)) )
         gROOT->Warning("TEfficiency::Combine","histograms have not the same binning -> results may be useless");
      if(vTotal.at(i)->GetNbinsX() < nbins_max) nbins_max = vTotal.at(i)->GetNbinsX();
   }

   //display information about combining
   if(bOutput) {
      gROOT->Info("TEfficiency::Combine","combining %i TEfficiency objects",(Int_t)vTotal.size());
      if(bWeights)
         gROOT->Info("TEfficiency::Combine","using custom weights");
      if(bStrict) {
         gROOT->Info("TEfficiency::Combine","using the following prior probability for the efficiency: P(e) ~ Beta(e,%.3lf,%.3lf)",alpha,beta);
      }
      else
         gROOT->Info("TEfficiency::Combine","using individual priors of each TEfficiency object");
      gROOT->Info("TEfficiency::Combine","confidence level = %.2lf",level);
   }

   //create TGraphAsymmErrors with efficiency
   std::vector<Double_t> x(nbins_max);
   std::vector<Double_t> xlow(nbins_max);
   std::vector<Double_t> xhigh(nbins_max);
   std::vector<Double_t> eff(nbins_max);
   std::vector<Double_t> efflow(nbins_max);
   std::vector<Double_t> effhigh(nbins_max);

   //parameters for combining:
   //number of objects
   Int_t num = vTotal.size();
   std::vector<Int_t> pass(num);
   std::vector<Int_t> total(num);

   //loop over all bins
   Double_t low = 0;
   Double_t up = 0;
   for(Int_t i=1; i <= nbins_max; ++i) {
      //the binning of the x-axis is taken from the first total histogram
      x[i-1] = vTotal.at(0)->GetBinCenter(i);
      xlow[i-1] = x[i-1] - vTotal.at(0)->GetBinLowEdge(i);
      xhigh[i-1] = vTotal.at(0)->GetBinWidth(i) - xlow[i-1];

      for(Int_t j = 0; j < num; ++j) {
         pass[j] = (Int_t)(vPassed.at(j)->GetBinContent(i) + 0.5);
         total[j] = (Int_t)(vTotal.at(j)->GetBinContent(i) + 0.5);
      }

      //fill efficiency and errors
      eff[i-1] = Combine(up,low,num,&pass[0],&total[0],alpha,beta,level,&vWeights[0],opt.Data());
      //did an error occured ?
      if(eff[i-1] == -1) {
         gROOT->Error("TEfficiency::Combine","error occured during combining");
         gROOT->Info("TEfficiency::Combine","stop combining");
         return 0;
      }
      efflow[i-1]= eff[i-1] - low;
      effhigh[i-1]= up - eff[i-1];
   }//loop over all bins

   TGraphAsymmErrors* gr = new TGraphAsymmErrors(nbins_max,&x[0],&eff[0],&xlow[0],&xhigh[0],&efflow[0],&effhigh[0]);

   return gr;
}

//______________________________________________________________________________
Int_t TEfficiency::DistancetoPrimitive(Int_t px, Int_t py)
{
   // Compute distance from point px,py to a graph.
   //
   //  Compute the closest distance of approach from point px,py to this line.
   //  The distance is computed in pixels units.
   //
   // Forward the call to the painted graph

   if (fPaintGraph) return fPaintGraph->DistancetoPrimitive(px,py);
   if (fPaintHisto) return fPaintHisto->DistancetoPrimitive(px,py);
   return 0;
}


//______________________________________________________________________________
void TEfficiency::Draw(Option_t* opt)
{
   //draws the current TEfficiency object
   //
   //options:
   //- 1-dimensional case: same options as TGraphAsymmErrors::Draw()
   //    but as default "AP" is used
   //- 2-dimensional case: same options as TH2::Draw()
   //- 3-dimensional case: not yet supported
   //
   // specific TEfficiency drawing options:
   // - E0 - plot bins where the total number of passed events is zero
   //      (the error interval will be [0,1] )

   //check options
   TString option = opt;
   option.ToLower();
   // use by default "AP"
   if (option.IsNull() ) option = "ap";

   if(gPad && !option.Contains("same"))
      gPad->Clear();
   else {
      // add always "a" if not present
      if (!option.Contains("a") ) option += "a";
   }

   // add always p to the option
   if (!option.Contains("p") ) option += "p";


   AppendPad(option.Data());
}

//______________________________________________________________________________
void TEfficiency::ExecuteEvent(Int_t event, Int_t px, Int_t py)
{
   // Execute action corresponding to one event.
   //
   //  This member function is called when the drawn class is clicked with the locator
   //  If Left button clicked on one of the line end points, this point
   //     follows the cursor until button is released.
   //
   //  if Middle button clicked, the line is moved parallel to itself
   //     until the button is released.
   // Forward the call to the underlying graph
   if (fPaintGraph) fPaintGraph->ExecuteEvent(event,px,py);
   else if (fPaintHisto) fPaintHisto->ExecuteEvent(event,px,py);
}

//______________________________________________________________________________
void TEfficiency::Fill(Bool_t bPassed,Double_t x,Double_t y,Double_t z)
{
   //This function is used for filling the two histograms.
   //
   //Input: bPassed - flag whether the current event passed the selection
   //                 true: both histograms are filled
   //                 false: only the total histogram is filled
   //       x       - x value
   //       y       - y value (use default=0 for 1-D efficiencies)
   //       z       - z value (use default=0 for 2-D or 1-D efficiencies)

   switch(GetDimension()) {
      case 1:
         fTotalHistogram->Fill(x);
         if(bPassed)
            fPassedHistogram->Fill(x);
         break;
      case 2:
         ((TH2*)(fTotalHistogram))->Fill(x,y);
         if(bPassed)
            ((TH2*)(fPassedHistogram))->Fill(x,y);
         break;
      case 3:
         ((TH3*)(fTotalHistogram))->Fill(x,y,z);
         if(bPassed)
            ((TH3*)(fPassedHistogram))->Fill(x,y,z);
         break;
   }
}

//______________________________________________________________________________
void TEfficiency::FillWeighted(Bool_t bPassed,Double_t weight,Double_t x,Double_t y,Double_t z)
{
   //This function is used for filling the two histograms with a weight.
   //
   //Input: bPassed - flag whether the current event passed the selection
   //                 true: both histograms are filled
   //                 false: only the total histogram is filled
   //       weight  - weight for the event
   //       x       - x value
   //       y       - y value (use default=0 for 1-D efficiencies)
   //       z       - z value (use default=0 for 2-D or 1-D efficiencies)
   //
   //Note: - this function will call SetUseWeightedEvents if it was not called by the user before

   if(!TestBit(kUseWeights))
   {
      Info("FillWeighted","call SetUseWeightedEvents() manually to ensure correct storage of sum of weights squared");
      SetUseWeightedEvents();
   }

   switch(GetDimension()) {
      case 1:
         fTotalHistogram->Fill(x,weight);
         if(bPassed)
            fPassedHistogram->Fill(x,weight);
         break;
      case 2:
         ((TH2*)(fTotalHistogram))->Fill(x,y,weight);
         if(bPassed)
            ((TH2*)(fPassedHistogram))->Fill(x,y,weight);
         break;
      case 3:
         ((TH3*)(fTotalHistogram))->Fill(x,y,z,weight);
         if(bPassed)
            ((TH3*)(fPassedHistogram))->Fill(x,y,z,weight);
         break;
   }
}

//______________________________________________________________________________
Int_t TEfficiency::FindFixBin(Double_t x,Double_t y,Double_t z) const
{
   //returns the global bin number containing the given values
   //
   //Note: - values which belong to dimensions higher than the current dimension
   //        of the TEfficiency object are ignored (i.e. for 1-dimensional
   //        efficiencies only the x-value is considered)

   Int_t nx = fTotalHistogram->GetXaxis()->FindFixBin(x);
   Int_t ny = 0;
   Int_t nz = 0;

   switch(GetDimension()) {
      case 3: nz = fTotalHistogram->GetZaxis()->FindFixBin(z);
      case 2: ny = fTotalHistogram->GetYaxis()->FindFixBin(y);break;
   }

   return GetGlobalBin(nx,ny,nz);
}

//______________________________________________________________________________
Int_t TEfficiency::Fit(TF1* f1,Option_t* opt)
{
   //fits the efficiency using the TBinomialEfficiencyFitter class
   //
   //The resulting fit function is added to the list of associated functions.
   //
   //Options: - "+": previous fitted functions in the list are kept, by default
   //                all functions in the list are deleted
   //         - for more fitting options see TBinomialEfficiencyFitter::Fit

   TString option = opt;
   option.ToLower();

   //replace existing functions in list with same name
   Bool_t bDeleteOld = true;
   if(option.Contains("+")) {
      option.ReplaceAll("+","");
      bDeleteOld = false;
   }

   TBinomialEfficiencyFitter Fitter(fPassedHistogram,fTotalHistogram);

   Int_t result = Fitter.Fit(f1,option.Data());

   //create copy which is appended to the list
   TF1* pFunc = new TF1(*f1);

   if(bDeleteOld) {
      TIter next(fFunctions);
      TObject* obj = 0;
      while((obj = next())) {
         if(obj->InheritsFrom(TF1::Class())) {
            fFunctions->Remove(obj);
            delete obj;
         }
      }
   }

   // create list if necessary
   if(!fFunctions)
      fFunctions = new TList();

   fFunctions->Add(pFunc);

   return result;
}

//______________________________________________________________________________
TH1* TEfficiency::GetCopyPassedHisto() const
{
   //returns a cloned version of fPassedHistogram
   //
   //Notes: - The histogram is filled with unit weights. You might want to scale
   //         it with the global weight GetWeight().
   //       - The returned object is owned by the user who has to care about the
   //         deletion of the new TH1 object.
   //       - This histogram is by default NOT attached to the current directory
   //         to avoid duplication of data. If you want to store it automatically
   //         during the next TFile::Write() command, you have to attach it to
   //         the corresponding directory.
   //Begin_html
   //<div class="code"><pre>
   //  TFile* pFile = new TFile("passed.root","update");
   //  TEfficiency* pEff = (TEfficiency*)gDirectory->Get("my_eff");
   //  TH1* copy = pEff->GetCopyPassedHisto();
   //  copy->SetDirectory(gDirectory);
   //  pFile->Write();
   //</pre></div>
   //<div class="clear"></div>
   //End_Html

   Bool_t bStatus = TH1::AddDirectoryStatus();
   TH1::AddDirectory(kFALSE);
   TH1* tmp = (TH1*)(fPassedHistogram->Clone());
   TH1::AddDirectory(bStatus);

   return tmp;
}

//______________________________________________________________________________
TH1* TEfficiency::GetCopyTotalHisto() const
{
   //returns a cloned version of fTotalHistogram
   //
   //Notes: - The histogram is filled with unit weights. You might want to scale
   //         it with the global weight GetWeight().
   //       - The returned object is owned by the user who has to care about the
   //         deletion of the new TH1 object.
   //       - This histogram is by default NOT attached to the current directory
   //         to avoid duplication of data. If you want to store it automatically
   //         during the next TFile::Write() command, you have to attach it to
   //         the corresponding directory.
   //Begin_Html
   //<div class="code"><pre>
   //  TFile* pFile = new TFile("total.root","update");
   //  TEfficiency* pEff = (TEfficiency*)gDirectory->Get("my_eff");
   //  TH1* copy = pEff->GetCopyTotalHisto();
   //  copy->SetDirectory(gDirectory);
   //  pFile->Write();
   //</pre></div>
   //<div class="clear"></div>
   //End_Html

   Bool_t bStatus = TH1::AddDirectoryStatus();
   TH1::AddDirectory(kFALSE);
   TH1* tmp = (TH1*)(fTotalHistogram->Clone());
   TH1::AddDirectory(bStatus);

   return tmp;
}

//______________________________________________________________________________
Int_t TEfficiency::GetDimension() const
{
   //returns the dimension of the current TEfficiency object

   return fTotalHistogram->GetDimension();
}

//______________________________________________________________________________
Double_t TEfficiency::GetEfficiency(Int_t bin) const
{
   //returns the efficiency in the given global bin
   //
   //Note: - The estimated efficiency depends on the chosen statistic option:
   //        for frequentist ones:
   //        Begin_Latex #hat{#varepsilon} = #frac{passed}{total} End_Latex
   //        for bayesian ones the expectation value of the resulting posterior
   //        distribution is returned:
   //        Begin_Latex #hat{#varepsilon} = #frac{passed + #alpha}{total + #alpha + #beta} End_Latex
   //        If the bit kPosteriorMode is set (or the method TEfficiency::UsePosteriorMode() has been called ) the
   //        mode (most probable value) of the posterior is returned:
   //        Begin_Latex #hat{#varepsilon} = #frac{passed + #alpha -1}{total + #alpha + #beta -2} End_Latex
   //
   //      - If the denominator is equal to 0, an efficiency of 0 is returned.
   //      - When  Begin_Latex passed + #alpha < 1 End_Latex or Begin_Latex total - passed + #beta < 1 End_latex the above
   //        formula for the mode is not valid. In these cases values the estimated efficiency is 0 or 1.

   Double_t total = fTotalHistogram->GetBinContent(bin);
   Double_t passed = fPassedHistogram->GetBinContent(bin);

   if(TestBit(kIsBayesian)) {

      // parameters for the beta prior distribution
      Double_t alpha = TestBit(kUseBinPrior) ? GetBetaAlpha(bin) : GetBetaAlpha();
      Double_t beta  = TestBit(kUseBinPrior) ? GetBetaBeta(bin)  : GetBetaBeta();

      Double_t aa,bb;
      if(TestBit(kUseWeights))
      {
         Double_t tw =  fTotalHistogram->GetBinContent(bin);
         Double_t tw2 = fTotalHistogram->GetSumw2()->At(bin);
         Double_t pw =  fPassedHistogram->GetBinContent(bin);

         if (tw2 <= 0 ) return pw/tw;

         // tw/tw2 renormalize the weights
         double norm = tw/tw2;
         aa =  pw * norm + alpha;
         bb =  (tw - pw) * norm + beta;
      }
      else
      {
         aa = passed + alpha;
         bb = total - passed + beta;
      }

      if (!TestBit(kPosteriorMode) )
         return BetaMean(aa,bb);
      else
         return BetaMode(aa,bb);

   }
   else
      return (total)? ((Double_t)passed)/total : 0;
}

//______________________________________________________________________________
Double_t TEfficiency::GetEfficiencyErrorLow(Int_t bin) const
{
   //returns the lower error on the efficiency in the given global bin
   //
   //The result depends on the current confidence level fConfLevel and the
   //chosen statistic option fStatisticOption. See SetStatisticOption(Int_t) for
   //more details.
   //
   //Note: If the histograms are filled with weights, only bayesian methods and the
   //      normal approximation are supported.

   Int_t total = (Int_t)fTotalHistogram->GetBinContent(bin);
   Int_t passed = (Int_t)fPassedHistogram->GetBinContent(bin);

   Double_t eff = GetEfficiency(bin);

   // check whether weights have been used
   if(TestBit(kUseWeights))
   {
      Double_t tw =  fTotalHistogram->GetBinContent(bin);
      Double_t tw2 = fTotalHistogram->GetSumw2()->At(bin);
      Double_t pw =  fPassedHistogram->GetBinContent(bin);
      Double_t pw2 = fPassedHistogram->GetSumw2()->At(bin);

      if(TestBit(kIsBayesian))
      {
         Double_t alpha = TestBit(kUseBinPrior) ? GetBetaAlpha(bin) : GetBetaAlpha();
         Double_t beta  = TestBit(kUseBinPrior) ? GetBetaBeta(bin)  : GetBetaBeta();

         if (tw2 <= 0) return 0;

         // tw/tw2 renormalize the weights
         Double_t norm = tw/tw2;
         Double_t aa =  pw * norm + alpha;
         Double_t bb =  (tw - pw) * norm + beta;
         Double_t low = 0;
         Double_t upper = 1;
         if(TestBit(kShortestInterval)) {
            TEfficiency::BetaShortestInterval(fConfLevel,aa,bb,low,upper);
         }
         else {
            low = TEfficiency::BetaCentralInterval(fConfLevel,aa,bb,false);
         }

         return eff - low;
      }
      else
      {
         if(fStatisticOption != kFNormal)
         {
            Warning("GetEfficiencyErrorLow","frequentist confidence intervals for weights are only supported by the normal approximation");
            Info("GetEfficiencyErrorLow","setting statistic option to kFNormal");
            const_cast<TEfficiency*>(this)->SetStatisticOption(kFNormal);
         }

         Double_t variance = ( pw2 * (1. - 2 * eff) + tw2 * eff *eff ) / ( tw * tw) ;
         Double_t sigma = sqrt(variance);

         Double_t prob = 0.5 * (1.- fConfLevel);
         Double_t delta = ROOT::Math::normal_quantile_c(prob, sigma);

         // avoid to return errors which makes eff-err < 0
         return (eff - delta < 0) ? eff : delta;
      }
   }
   else
   {
      if(TestBit(kIsBayesian))
      {
         // parameters for the beta prior distribution
         Double_t alpha = TestBit(kUseBinPrior) ? GetBetaAlpha(bin) : GetBetaAlpha();
         Double_t beta  = TestBit(kUseBinPrior) ? GetBetaBeta(bin)  : GetBetaBeta();
         return (eff - Bayesian(total,passed,fConfLevel,alpha,beta,false,TestBit(kShortestInterval)));
      }
      else
         return (eff - fBoundary(total,passed,fConfLevel,false));
   }
}

//______________________________________________________________________________
Double_t TEfficiency::GetEfficiencyErrorUp(Int_t bin) const
{
   //returns the upper error on the efficiency in the given global bin
   //
   //The result depends on the current confidence level fConfLevel and the
   //chosen statistic option fStatisticOption. See SetStatisticOption(Int_t) for
   //more details.
   //
   //Note: If the histograms are filled with weights, only bayesian methods and the
   //      normal approximation are supported.

   Int_t total = (Int_t)fTotalHistogram->GetBinContent(bin);
   Int_t passed = (Int_t)fPassedHistogram->GetBinContent(bin);

   Double_t eff = GetEfficiency(bin);

   // check whether weights have been used
   if(TestBit(kUseWeights))
   {
      Double_t tw =  fTotalHistogram->GetBinContent(bin);
      Double_t tw2 = fTotalHistogram->GetSumw2()->At(bin);
      Double_t pw =  fPassedHistogram->GetBinContent(bin);
      Double_t pw2 = fPassedHistogram->GetSumw2()->At(bin);

      if(TestBit(kIsBayesian))
      {
         Double_t alpha = TestBit(kUseBinPrior) ? GetBetaAlpha(bin) : GetBetaAlpha();
         Double_t beta  = TestBit(kUseBinPrior) ? GetBetaBeta(bin)  : GetBetaBeta();

         if (tw2 <= 0) return 0;

         // tw/tw2 renormalize the weights
         Double_t norm = tw/tw2;
         Double_t aa =  pw * norm + alpha;
         Double_t bb =  (tw - pw) * norm + beta;
         Double_t low = 0;
         Double_t upper = 1;
         if(TestBit(kShortestInterval)) {
            TEfficiency::BetaShortestInterval(fConfLevel,aa,bb,low,upper);
         }
         else {
            upper = TEfficiency::BetaCentralInterval(fConfLevel,aa,bb,true);
         }

         return upper - eff;
      }
      else
      {
         if(fStatisticOption != kFNormal)
         {
            Warning("GetEfficiencyErrorUp","frequentist confidence intervals for weights are only supported by the normal approximation");
            Info("GetEfficiencyErrorUp","setting statistic option to kFNormal");
            const_cast<TEfficiency*>(this)->SetStatisticOption(kFNormal);
         }

         Double_t variance = ( pw2 * (1. - 2 * eff) + tw2 * eff *eff ) / ( tw * tw) ;
         Double_t sigma = sqrt(variance);

         Double_t prob = 0.5 * (1.- fConfLevel);
         Double_t delta = ROOT::Math::normal_quantile_c(prob, sigma);

         return (eff + delta > 1) ? 1.-eff : delta;
      }
   }
   else
   {
      if(TestBit(kIsBayesian))
      {
         // parameters for the beta prior distribution
         Double_t alpha = TestBit(kUseBinPrior) ? GetBetaAlpha(bin) : GetBetaAlpha();
         Double_t beta  = TestBit(kUseBinPrior) ? GetBetaBeta(bin)  : GetBetaBeta();
         return (Bayesian(total,passed,fConfLevel,alpha,beta,true,TestBit(kShortestInterval)) - eff);
      }
      else
         return fBoundary(total,passed,fConfLevel,true) - eff;
   }
}

//______________________________________________________________________________
Int_t TEfficiency::GetGlobalBin(Int_t binx,Int_t biny,Int_t binz) const
{
   //returns the global bin number which can be used as argument for the
   //following functions:
   //
   // - GetEfficiency(bin), GetEfficiencyErrorLow(bin), GetEfficiencyErrorUp(bin)
   // - SetPassedEvents(bin), SetTotalEvents(bin)
   //
   //see TH1::GetBin() for conventions on numbering bins

   return fTotalHistogram->GetBin(binx,biny,binz);
}

//______________________________________________________________________________
TList* TEfficiency::GetListOfFunctions()
{
   return (fFunctions) ? fFunctions : fFunctions = new TList();
}

//______________________________________________________________________________
Long64_t TEfficiency::Merge(TCollection* pList)
{
   //merges the TEfficiency objects in the given list to the given
   //TEfficiency object using the operator+=(TEfficiency&)
   //
   //The merged result is stored in the current object. The statistic options and
   //the confidence level are taken from the current object.
   //
   //This function should be used when all TEfficiency objects correspond to
   //the same process.
   //
   //The new weight is set according to:
   //Begin_Latex #frac{1}{w_{new}} = #sum_{i} \frac{1}{w_{i}}End_Latex

   if(!pList->IsEmpty()) {
      TIter next(pList);
      TObject* obj = 0;
      TEfficiency* pEff = 0;
      while((obj = next())) {
         pEff = dynamic_cast<TEfficiency*>(obj);
         if(pEff) {
            *this += *pEff;
         }
      }
   }
   return (Long64_t)fTotalHistogram->GetEntries();
}

//______________________________________________________________________________
Double_t TEfficiency::Normal(Int_t total,Int_t passed,Double_t level,Bool_t bUpper)
{
   //returns the confidence limits for the efficiency supposing that the
   //efficiency follows a normal distribution with the rms below
   //
   //Input: - total : number of total events
   //       - passed: 0 <= number of passed events <= total
   //       - level : confidence level
   //       - bUpper: true  - upper boundary is returned
   //                 false - lower boundary is returned
   //
   //calculation:
   //Begin_Latex(separator='=',align='rl')
   // #hat{#varepsilon} = #frac{passed}{total}
   // #sigma_{#varepsilon} = #sqrt{#frac{#hat{#varepsilon} (1 - #hat{#varepsilon})}{total}}
   // #varepsilon_{low} = #hat{#varepsilon} #pm #Phi^{-1}(#frac{level}{2},#sigma_{#varepsilon})
   //End_Latex

   Double_t alpha = (1.0 - level)/2;
   if (total == 0) return (bUpper) ? 1 : 0;
   Double_t average = ((Double_t)passed) / total;
   Double_t sigma = std::sqrt(average * (1 - average) / total);
   Double_t delta = ROOT::Math::normal_quantile(1 - alpha,sigma);

   if(bUpper)
      return ((average + delta) > 1) ? 1.0 : (average + delta);
   else
      return ((average - delta) < 0) ? 0.0 : (average - delta);
}

//______________________________________________________________________________
TEfficiency& TEfficiency::operator+=(const TEfficiency& rhs)
{
   //adds the histograms of another TEfficiency object to current histograms
   //
   //The statistic options and the confidence level remain unchanged.
   //
   //fTotalHistogram += rhs.fTotalHistogram;
   //fPassedHistogram += rhs.fPassedHistogram;
   //
   //calculates a new weight:
   //current weight of this TEfficiency object = Begin_Latex w_{1} End_Latex
   //weight of rhs = Begin_Latex w_{2} End_Latex
   //Begin_Latex w_{new} = \frac{w_{1} \times w_{2}}{w_{1} + w_{2}}End_Latex


   if (fTotalHistogram == 0 && fPassedHistogram == 0) {
      // efficiency is empty just copy it over
      *this = rhs;
      return *this;
   }
   else if (fTotalHistogram == 0 || fPassedHistogram == 0) {
      Fatal("operator+=","Adding to a non consistent TEfficiency object which has not a total or a passed histogram ");
      return *this;
   }

   if (rhs.fTotalHistogram == 0 && rhs.fTotalHistogram == 0 ) {
      Warning("operator+=","no operation: adding an empty object");
      return *this;
   }
   else  if (rhs.fTotalHistogram == 0  || rhs.fTotalHistogram == 0 ) {
      Fatal("operator+=","Adding a non consistent TEfficiency object which has not a total or a passed histogram ");
      return *this;
   }

   fTotalHistogram->ResetBit(TH1::kIsAverage);
   fPassedHistogram->ResetBit(TH1::kIsAverage);

   fTotalHistogram->Add(rhs.fTotalHistogram);
   fPassedHistogram->Add(rhs.fPassedHistogram);

   SetWeight((fWeight * rhs.GetWeight())/(fWeight + rhs.GetWeight()));

   return *this;
}

//______________________________________________________________________________
TEfficiency& TEfficiency::operator=(const TEfficiency& rhs)
{
   //assignment operator
   //
   //The histograms, statistic option, confidence level, weight and paint styles
   //of rhs are copied to the this TEfficiency object.
   //
   //Note: - The list of associated functions is not copied. After this
   //        operation the list of associated functions is empty.

   if(this != &rhs)
   {
      //statistic options
      SetStatisticOption(rhs.GetStatisticOption());
      SetConfidenceLevel(rhs.GetConfidenceLevel());
      SetBetaAlpha(rhs.GetBetaAlpha());
      SetBetaBeta(rhs.GetBetaBeta());
      SetWeight(rhs.GetWeight());

      //associated list of functions
      if(fFunctions)
         fFunctions->Delete();

      //copy histograms
      delete fTotalHistogram;
      delete fPassedHistogram;

      Bool_t bStatus = TH1::AddDirectoryStatus();
      TH1::AddDirectory(kFALSE);
      fTotalHistogram = (TH1*)(rhs.fTotalHistogram->Clone());
      fPassedHistogram = (TH1*)(rhs.fPassedHistogram->Clone());
      TH1::AddDirectory(bStatus);

      //delete temporary paint objects
      delete fPaintHisto;
      delete fPaintGraph;
      fPaintHisto = 0;
      fPaintGraph = 0;

      //copy style
      rhs.TAttLine::Copy(*this);
      rhs.TAttFill::Copy(*this);
      rhs.TAttMarker::Copy(*this);
   }

   return *this;
}

//______________________________________________________________________________
void TEfficiency::Paint(const Option_t* opt)
{
   //paints this TEfficiency object
   //
   //For details on the possible option see Draw(Option_t*)
   //
   // Note for 1D classes
   // In 1D the TEfficiency uses a TGraphAsymmErrors for drawing
   // The TGraph is created only the first time Paint is used. The user can manipulate the
   // TGraph via the method TEfficiency::GetPaintedGraph()
   // The TGraph creates behing an histogram for the axis. The histogram is created also only the first time.
   // If the axis needs to be updated because in the meantime the class changed use this trick
   // which will trigger a re-calculation of the axis of the graph
   // TEfficiency::GetPaintedGraph()->Set(0)
   //
   // Note that in order to access the painted graph via GetPaintedGraph() you need either to call Paint or better
   // gPad->Update();
   //



   if(!gPad)
      return;


   //use TGraphAsymmErrors for painting
   if(GetDimension() == 1) {
      if(!fPaintGraph) {
         fPaintGraph = CreateGraph(opt);
      }
      else
         // update existing graph already created
         FillGraph(fPaintGraph, opt);

      //paint graph

      fPaintGraph->Paint(opt);

      //paint all associated functions
      if(fFunctions) {
         //paint box with fit parameters
         gStyle->SetOptFit(1);
         TIter next(fFunctions);
         TObject* obj = 0;
         while((obj = next())) {
            if(obj->InheritsFrom(TF1::Class())) {
               fPaintGraph->PaintStats((TF1*)obj);
               ((TF1*)obj)->Paint("sameC");
            }
         }
      }

      return;
   }

   //use TH2 for painting
   if(GetDimension() == 2) {
      if(!fPaintHisto) {
         fPaintHisto = CreateHistogram();
      }
      else
         FillHistogram(fPaintHisto);

      //paint histogram
      fPaintHisto->Paint(opt);
      return;
   }
   Warning("Paint","Painting 3D efficiency is not implemented");
}

//______________________________________________________________________________
void TEfficiency::SavePrimitive(ostream& out,Option_t* opt)
{
   //have histograms fixed bins along each axis?
   Bool_t equi_bins = true;

   //indentation
   TString indent = "   ";
   //names for arrays containing the bin edges
   //static counter needed if more objects are saved
   static Int_t naxis = 0;
   TString sxaxis="xAxis",syaxis="yAxis",szaxis="zAxis";

   //note the missing break statements!
   switch(GetDimension()) {
      case 3:
         equi_bins = equi_bins && !fTotalHistogram->GetZaxis()->GetXbins()->fArray
         && !fTotalHistogram->GetZaxis()->GetXbins()->fN;
      case 2:
         equi_bins = equi_bins && !fTotalHistogram->GetYaxis()->GetXbins()->fArray
         && !fTotalHistogram->GetYaxis()->GetXbins()->fN;
      case 1:
         equi_bins = equi_bins && !fTotalHistogram->GetXaxis()->GetXbins()->fArray
         && !fTotalHistogram->GetXaxis()->GetXbins()->fN;
   }

   //create arrays containing the variable binning
   if(!equi_bins) {
      Int_t i;
      ++naxis;
      sxaxis += naxis;
      syaxis += naxis;
      szaxis += naxis;
      //x axis
      out << indent << "Double_t " << sxaxis << "["
      << fTotalHistogram->GetXaxis()->GetXbins()->fN << "] = {";
      for (i = 0; i < fTotalHistogram->GetXaxis()->GetXbins()->fN; ++i) {
         if (i != 0) out << ", ";
         out << fTotalHistogram->GetXaxis()->GetXbins()->fArray[i];
      }
      out << "}; " << std::endl;
      //y axis
      if(GetDimension() > 1) {
         out << indent << "Double_t " << syaxis << "["
         << fTotalHistogram->GetYaxis()->GetXbins()->fN << "] = {";
         for (i = 0; i < fTotalHistogram->GetYaxis()->GetXbins()->fN; ++i) {
            if (i != 0) out << ", ";
            out << fTotalHistogram->GetYaxis()->GetXbins()->fArray[i];
         }
         out << "}; " << std::endl;
      }
      //z axis
      if(GetDimension() > 2) {
         out << indent << "Double_t " << szaxis << "["
         << fTotalHistogram->GetZaxis()->GetXbins()->fN << "] = {";
         for (i = 0; i < fTotalHistogram->GetZaxis()->GetXbins()->fN; ++i) {
            if (i != 0) out << ", ";
            out << fTotalHistogram->GetZaxis()->GetXbins()->fArray[i];
         }
         out << "}; " << std::endl;
      }
   }//creating variable binning

   //TEfficiency pointer has efficiency name + counter
   static Int_t eff_count = 0;
   ++eff_count;
   TString eff_name = GetName();
   eff_name += eff_count;

   const char* name = eff_name.Data();

   //construct TEfficiency object
   const char quote = '"';
   out << indent << std::endl;
   out << indent << ClassName() << " * " << name << " = new " << ClassName()
   << "(" << quote << GetName() << quote << "," << quote
   << GetTitle() << quote <<",";
   //fixed bin size -> use n,min,max constructor
   if(equi_bins) {
      out << fTotalHistogram->GetXaxis()->GetNbins() << ","
      << fTotalHistogram->GetXaxis()->GetXmin() << ","
      << fTotalHistogram->GetXaxis()->GetXmax();
      if(GetDimension() > 1) {
         out << "," << fTotalHistogram->GetYaxis()->GetNbins() << ","
         << fTotalHistogram->GetYaxis()->GetXmin() << ","
         << fTotalHistogram->GetYaxis()->GetXmax();
      }
      if(GetDimension() > 2) {
         out << "," << fTotalHistogram->GetZaxis()->GetNbins() << ","
         << fTotalHistogram->GetZaxis()->GetXmin() << ","
         << fTotalHistogram->GetZaxis()->GetXmax();
      }
   }
   //variable bin size -> use n,*bins constructor
   else {
      out << fTotalHistogram->GetXaxis()->GetNbins() << "," << sxaxis;
      if(GetDimension() > 1)
         out << "," << fTotalHistogram->GetYaxis()->GetNbins() << ","
         << syaxis;
      if(GetDimension() > 2)
         out << "," << fTotalHistogram->GetZaxis()->GetNbins() << ","
         << szaxis;
   }
   out << ");" << std::endl;
   out << indent << std::endl;

   //set statistic options
   out << indent << name << "->SetConfidenceLevel(" << fConfLevel << ");"
   << std::endl;
   out << indent << name << "->SetBetaAlpha(" << fBeta_alpha << ");"
   << std::endl;
   out << indent << name << "->SetBetaBeta(" << fBeta_beta << ");" << std::endl;
   out << indent << name << "->SetWeight(" << fWeight << ");" << std::endl;
   out << indent << name << "->SetStatisticOption(" << fStatisticOption << ");"
   << std::endl;
   out << indent << name << "->SetPosteriorMode(" << TestBit(kPosteriorMode) << ");" << std::endl;
   out << indent << name << "->SetShortestInterval(" << TestBit(kShortestInterval) << ");" << std::endl;
   if(TestBit(kUseWeights))
      out << indent << name << "->SetUseWeightedEvents();" << std::endl;

   // save bin-by-bin prior parameters
   for(unsigned int i = 0; i < fBeta_bin_params.size(); ++i)
   {
      out << indent << name << "->SetBetaBinParameters(" << i << "," << fBeta_bin_params.at(i).first
      << "," << fBeta_bin_params.at(i).second << ");" << std::endl;
   }

   //set bin contents
   Int_t nbins = fTotalHistogram->GetNbinsX() + 2;
   if(GetDimension() > 1)
      nbins *= fTotalHistogram->GetNbinsY() + 2;
   if(GetDimension() > 2)
      nbins *= fTotalHistogram->GetNbinsZ() + 2;

   //important: set first total number than passed number
   for(Int_t i = 0; i < nbins; ++i) {
      out << indent << name <<"->SetTotalEvents(" << i << "," <<
      fTotalHistogram->GetBinContent(i) << ");" << std::endl;
      out << indent << name <<"->SetPassedEvents(" << i << "," <<
      fPassedHistogram->GetBinContent(i) << ");" << std::endl;
   }

   //save list of functions
   TIter next(fFunctions);
   TObject* obj = 0;
   while((obj = next())) {
      obj->SavePrimitive(out,"nodraw");
      if(obj->InheritsFrom(TF1::Class())) {
         out << indent << name << "->GetListOfFunctions()->Add("
         << obj->GetName() << ");" << std::endl;
      }
   }

   //set style
   SaveFillAttributes(out,name);
   SaveLineAttributes(out,name);
   SaveMarkerAttributes(out,name);

   //draw TEfficiency object
   TString option = opt;
   option.ToLower();
   if (!option.Contains("nodraw"))
      out<< indent << name<< "->Draw(" << quote << opt << quote << ");"
      << std::endl;
}

//______________________________________________________________________________
void TEfficiency::SetBetaAlpha(Double_t alpha)
{
   //sets the shape parameter Begin_Latex \alpha End_Latex
   //
   //The prior probability of the efficiency is given by the beta distribution:
   //Begin_Latex
   // f(\varepsilon;\alpha;\beta) = \frac{1}{B(\alpha,\beta)} \varepsilon^{\alpha-1} (1 - \varepsilon)^{\beta-1}
   //End_Latex
   //
   //Note: - both shape parameters have to be positive (i.e. > 0)

   if(alpha > 0)
      fBeta_alpha = alpha;
   else
      Warning("SetBetaAlpha(Double_t)","invalid shape parameter %.2lf",alpha);
}

//______________________________________________________________________________
void TEfficiency::SetBetaBeta(Double_t beta)
{
   //sets the shape parameter Begin_Latex \beta End_Latex
   //
   //The prior probability of the efficiency is given by the beta distribution:
   //Begin_Latex
   // f(\varepsilon;\alpha,\beta) = \frac{1}{B(\alpha,\beta)} \varepsilon^{\alpha-1} (1 - \varepsilon)^{\beta-1}
   //End_Latex
   //
   //Note: - both shape parameters have to be positive (i.e. > 0)

   if(beta > 0)
      fBeta_beta = beta;
   else
      Warning("SetBetaBeta(Double_t)","invalid shape parameter %.2lf",beta);
}

//______________________________________________________________________________
void TEfficiency::SetBetaBinParameters(Int_t bin, Double_t alpha, Double_t beta)
{
   //sets different  shape parameter Begin_Latex \alpha and \beta End_Latex
   // for the prior distribution for each bin. By default the global parameter are used if they are not set
   // for the specific bin
   //The prior probability of the efficiency is given by the beta distribution:
   //Begin_Latex
   // f(\varepsilon;\alpha;\beta) = \frac{1}{B(\alpha,\beta)} \varepsilon^{\alpha-1} (1 - \varepsilon)^{\beta-1}
   //End_Latex
   //
   //Note: - both shape parameters have to be positive (i.e. > 0)
   //      - bin gives the global bin number (cf. GetGlobalBin)

   if (!fPassedHistogram || !fTotalHistogram) return;
   TH1 * h1 = fTotalHistogram;
   // doing this I get h1->fN which is available only for a TH1D
   UInt_t n = h1->GetBin(h1->GetNbinsX()+1, h1->GetNbinsY()+1, h1->GetNbinsZ()+1 ) + 1;

   // in case vector is not created do with default alpha, beta params
   if (fBeta_bin_params.size() != n )
      fBeta_bin_params = std::vector<std::pair<Double_t, Double_t> >(n, std::make_pair(fBeta_alpha, fBeta_beta) );

   // vector contains also values for under/overflows
   fBeta_bin_params[bin] = std::make_pair(alpha,beta);
   SetBit(kUseBinPrior,true);

}

//______________________________________________________________________________
Bool_t TEfficiency::SetBins(Int_t nx, Double_t xmin, Double_t xmax)
{
   // set the bins for the underlined passed and total histograms
   // If the class have been already filled the previous contents will be lost
   if (GetDimension() != 1) {
      Error("SetBins","Using wrong SetBins function for a %d-d histogram",GetDimension());
      return kFALSE;
   }
   if (fTotalHistogram->GetEntries() != 0 ) {
      Warning("SetBins","Histogram entries will be lost after SetBins");
      fPassedHistogram->Reset();
      fTotalHistogram->Reset();
   }
   fPassedHistogram->SetBins(nx,xmin,xmax);
   fTotalHistogram->SetBins(nx,xmin,xmax);
   return kTRUE;
}

//______________________________________________________________________________
Bool_t TEfficiency::SetBins(Int_t nx, const Double_t *xBins)
{
   // set the bins for the underlined passed and total histograms
   // If the class have been already filled the previous contents will be lost
   if (GetDimension() != 1) {
      Error("SetBins","Using wrong SetBins function for a %d-d histogram",GetDimension());
      return kFALSE;
   }
   if (fTotalHistogram->GetEntries() != 0 ) {
      Warning("SetBins","Histogram entries will be lost after SetBins");
      fPassedHistogram->Reset();
      fTotalHistogram->Reset();
   }
   fPassedHistogram->SetBins(nx,xBins);
   fTotalHistogram->SetBins(nx,xBins);
   return kTRUE;
}

//______________________________________________________________________________
Bool_t TEfficiency::SetBins(Int_t nx, Double_t xmin, Double_t xmax, Int_t ny, Double_t ymin, Double_t ymax)
{
   // set the bins for the underlined passed and total histograms
   // If the class have been already filled the previous contents will be lost
   if (GetDimension() != 2) {
      Error("SetBins","Using wrong SetBins function for a %d-d histogram",GetDimension());
      return kFALSE;
   }
   if (fTotalHistogram->GetEntries() != 0 ) {
      Warning("SetBins","Histogram entries will be lost after SetBins");
      fPassedHistogram->Reset();
      fTotalHistogram->Reset();
   }
   fPassedHistogram->SetBins(nx,xmin,xmax,ny,ymin,ymax);
   fTotalHistogram->SetBins(nx,xmin,xmax,ny,ymin,ymax);
   return kTRUE;
}

//______________________________________________________________________________
Bool_t TEfficiency::SetBins(Int_t nx, const Double_t *xBins, Int_t ny, const Double_t *yBins)
{
   // set the bins for the underlined passed and total histograms
   // If the class have been already filled the previous contents will be lost
   if (GetDimension() != 2) {
      Error("SetBins","Using wrong SetBins function for a %d-d histogram",GetDimension());
      return kFALSE;
   }
   if (fTotalHistogram->GetEntries() != 0 ) {
      Warning("SetBins","Histogram entries will be lost after SetBins");
      fPassedHistogram->Reset();
      fTotalHistogram->Reset();
   }
   fPassedHistogram->SetBins(nx,xBins,ny,yBins);
   fTotalHistogram->SetBins(nx,xBins,ny,yBins);
   return kTRUE;
}

//______________________________________________________________________________
Bool_t TEfficiency::SetBins(Int_t nx, Double_t xmin, Double_t xmax, Int_t ny, Double_t ymin, Double_t ymax,
                            Int_t nz, Double_t zmin, Double_t zmax)
{
   // set the bins for the underlined passed and total histograms
   // If the class have been already filled the previous contents will be lost
   if (GetDimension() != 3) {
      Error("SetBins","Using wrong SetBins function for a %d-d histogram",GetDimension());
      return kFALSE;
   }
   if (fTotalHistogram->GetEntries() != 0 ) {
      Warning("SetBins","Histogram entries will be lost after SetBins");
      fPassedHistogram->Reset();
      fTotalHistogram->Reset();
   }
   fPassedHistogram->SetBins(nx,xmin,xmax,ny,ymin,ymax,nz,zmin,zmax);
   fTotalHistogram->SetBins (nx,xmin,xmax,ny,ymin,ymax,nz,zmin,zmax);
   return kTRUE;
}

//______________________________________________________________________________
Bool_t TEfficiency::SetBins(Int_t nx, const Double_t *xBins, Int_t ny, const Double_t *yBins, Int_t nz,
                            const Double_t *zBins )
{
   // set the bins for the underlined passed and total histograms
   // If the class have been already filled the previous contents will be lost
   if (GetDimension() != 3) {
      Error("SetBins","Using wrong SetBins function for a %d-d histogram",GetDimension());
      return kFALSE;
   }
   if (fTotalHistogram->GetEntries() != 0 ) {
      Warning("SetBins","Histogram entries will be lost after SetBins");
      fPassedHistogram->Reset();
      fTotalHistogram->Reset();
   }
   fPassedHistogram->SetBins(nx,xBins,ny,yBins,nz,zBins);
   fTotalHistogram->SetBins(nx,xBins,ny,yBins,nz,zBins);
   return kTRUE;
}

//______________________________________________________________________________
void TEfficiency::SetConfidenceLevel(Double_t level)
{
   //sets the confidence level (0 < level < 1)
   // The default value is 1-sigma :~ 0.683

   if((level > 0) && (level < 1))
      fConfLevel = level;
   else
      Warning("SetConfidenceLevel(Double_t)","invalid confidence level %.2lf",level);
}

//______________________________________________________________________________
void TEfficiency::SetDirectory(TDirectory* dir)
{
   //sets the directory holding this TEfficiency object
   //
   //A reference to this TEfficiency object is removed from the current
   //directory (if it exists) and a new reference to this TEfficiency object is
   //added to the given directory.
   //
   //Notes: - If the given directory is 0, the TEfficiency object does not
   //         belong to any directory and will not be written to file during the
   //         next TFile::Write() command.

   if(fDirectory == dir)
      return;
   if(fDirectory)
      fDirectory->Remove(this);
   fDirectory = dir;
   if(fDirectory)
      fDirectory->Append(this);
}

//______________________________________________________________________________
void TEfficiency::SetName(const char* name)
{
   //sets the name
   //
   //Note: The names of the internal histograms are set to "name + _total" and
   //      "name + _passed" respectively.

   TNamed::SetName(name);

   //setting the names (appending the correct ending)
   TString name_total = name + TString("_total");
   TString name_passed = name + TString("_passed");
   fTotalHistogram->SetName(name_total);
   fPassedHistogram->SetName(name_passed);
}

//______________________________________________________________________________
Bool_t TEfficiency::SetPassedEvents(Int_t bin,Int_t events)
{
   //sets the number of passed events in the given global bin
   //
   //returns "true" if the number of passed events has been updated
   //otherwise "false" ist returned
   //
   //Note: - requires: 0 <= events <= fTotalHistogram->GetBinContent(bin)

   if(events <= fTotalHistogram->GetBinContent(bin)) {
      fPassedHistogram->SetBinContent(bin,events);
      return true;
   }
   else {
      Error("SetPassedEvents(Int_t,Int_t)","total number of events (%.1lf) in bin %i is less than given number of passed events %i",fTotalHistogram->GetBinContent(bin),bin,events);
      return false;
   }
}

//______________________________________________________________________________
Bool_t TEfficiency::SetPassedHistogram(const TH1& rPassed,Option_t* opt)
{
   //sets the histogram containing the passed events
   //
   //The given histogram is cloned and stored internally as histogram containing
   //the passed events. The given histogram has to be consistent with the current
   //fTotalHistogram (see CheckConsistency(const TH1&,const TH1&)).
   //The method returns whether the fPassedHistogram has been replaced (true) or
   //not (false).
   //
   //Note: The list of associated functions fFunctions is cleared.
   //
   //Option: - "f": force the replacement without checking the consistency
   //               This can lead to inconsistent histograms and useless results
   //               or unexpected behaviour. But sometimes it might be the only
   //               way to change the histograms. If you use this option, you
   //               should ensure that the fTotalHistogram is replaced by a
   //               consistent one (with respect to rPassed) as well.

   TString option = opt;
   option.ToLower();

   Bool_t bReplace = option.Contains("f");

   if(!bReplace)
      bReplace = CheckConsistency(rPassed,*fTotalHistogram,"w");

   if(bReplace) {
      delete fPassedHistogram;
      Bool_t bStatus = TH1::AddDirectoryStatus();
      TH1::AddDirectory(kFALSE);
      fPassedHistogram = (TH1*)(rPassed.Clone());
      fPassedHistogram->SetNormFactor(0);
      TH1::AddDirectory(bStatus);

      if(fFunctions)
         fFunctions->Delete();

      //check whether histogram is filled with weights
      Double_t statpass[TH1::kNstat];
      rPassed.GetStats(statpass);
      //require: sum of weights == sum of weights^2
      if(TMath::Abs(statpass[0]-statpass[1]) > 1e-5)
         SetUseWeightedEvents();

      return true;
   }
   else
      return false;
}

//______________________________________________________________________________
void TEfficiency::SetStatisticOption(EStatOption option)
{
   //sets the statistic option which affects the calculation of the confidence interval
   //
   //Options:
   //- kFCP (=0)(default): using the Clopper-Pearson interval (recommended by PDG)
   //                      sets kIsBayesian = false
   //                      see also ClopperPearson
   //- kFNormal   (=1)   : using the normal approximation
   //                      sets kIsBayesian = false
   //                      see also Normal
   //- kFWilson   (=2)   : using the Wilson interval
   //                      sets kIsBayesian = false
   //                      see also Wilson
   //- kFAC       (=3)   : using the Agresti-Coull interval
   //                      sets kIsBayesian = false
   //                      see also AgrestiCoull
   //- kFFC       (=4)   : using the Feldman-Cousins frequentist method
   //                      sets kIsBayesian = false
   //                      see also FeldmanCousins
   //- kBJeffrey  (=5)   : using the Jeffrey interval
   //                      sets kIsBayesian = true, fBeta_alpha = 0.5 and fBeta_beta = 0.5
   //                      see also Bayesian
   //- kBUniform  (=6)   : using a uniform prior
   //                      sets kIsBayesian = true, fBeta_alpha = 1 and fBeta_beta = 1
   //                      see also Bayesian
   //- kBBayesian (=7)   : using a custom prior defined by fBeta_alpha and fBeta_beta
   //                      sets kIsBayesian = true
   //                      see also Bayesian

   fStatisticOption = option;

   switch(option)
   {
      case kFCP:
         fBoundary = &ClopperPearson;
         SetBit(kIsBayesian,false);
         break;
      case kFNormal:
         fBoundary = &Normal;
         SetBit(kIsBayesian,false);
         break;
      case kFWilson:
         fBoundary = &Wilson;
         SetBit(kIsBayesian,false);
         break;
      case kFAC:
         fBoundary = &AgrestiCoull;
         SetBit(kIsBayesian,false);
         break;
      case kFFC:
         fBoundary = &FeldmanCousins;
         SetBit(kIsBayesian,false);
         break;
      case kBJeffrey:
         fBeta_alpha = 0.5;
         fBeta_beta = 0.5;
         SetBit(kIsBayesian,true);
         SetBit(kUseBinPrior,false);
         break;
      case kBUniform:
         fBeta_alpha = 1;
         fBeta_beta = 1;
         SetBit(kIsBayesian,true);
         SetBit(kUseBinPrior,false);
         break;
      case kBBayesian:
         SetBit(kIsBayesian,true);
         break;
      default:
         fStatisticOption = kFCP;
         fBoundary = &ClopperPearson;
         SetBit(kIsBayesian,false);
   }
}

//______________________________________________________________________________
void TEfficiency::SetTitle(const char* title)
{
   //sets the title
   //
   //Notes: - The titles of the internal histograms are set to "title + (total)"
   //         or "title + (passed)" respectively.
   //       - It is possible to label the axis of the histograms as usual (see
   //         TH1::SetTitle).
   //
   //Example: Setting the title to "My Efficiency" and label the axis
   //Begin_Html
   //<div class="code"><pre>
   //pEff->SetTitle("My Efficiency;x label;eff");
   //</pre></div>
   //<div class="clear"></div>
   //End_Html


   //setting the titles (looking for the first semicolon and insert the tokens there)
   TString title_passed = title;
   TString title_total = title;
   Ssiz_t pos = title_passed.First(";");
   if (pos != kNPOS) {
      title_passed.Insert(pos," (passed)");
      title_total.Insert(pos," (total)");
   }
   else {
      title_passed.Append(" (passed)");
      title_total.Append(" (total)");
   }
   fPassedHistogram->SetTitle(title_passed);
   fTotalHistogram->SetTitle(title_total);

   // strip (total) for the TEfficiency title
   // HIstogram SetTitle has already stripped the axis
   TString teffTitle = fTotalHistogram->GetTitle();
   teffTitle.ReplaceAll(" (total)","");
   TNamed::SetTitle(teffTitle);

}

//______________________________________________________________________________
Bool_t TEfficiency::SetTotalEvents(Int_t bin,Int_t events)
{
   //sets the number of total events in the given global bin
   //
   //returns "true" if the number of total events has been updated
   //otherwise "false" ist returned
   //
   //Note: - requires: fPassedHistogram->GetBinContent(bin) <= events

   if(events >= fPassedHistogram->GetBinContent(bin)) {
      fTotalHistogram->SetBinContent(bin,events);
      return true;
   }
   else {
      Error("SetTotalEvents(Int_t,Int_t)","passed number of events (%.1lf) in bin %i is bigger than given number of total events %i",fPassedHistogram->GetBinContent(bin),bin,events);
      return false;
   }
}

//______________________________________________________________________________
Bool_t TEfficiency::SetTotalHistogram(const TH1& rTotal,Option_t* opt)
{
   //sets the histogram containing all events
   //
   //The given histogram is cloned and stored internally as histogram containing
   //all events. The given histogram has to be consistent with the current
   //fPassedHistogram (see CheckConsistency(const TH1&,const TH1&)).
   //The method returns whether the fTotalHistogram has been replaced (true) or
   //not (false).
   //
   //Note: The list of associated functions fFunctions is cleared.
   //
   //Option: - "f": force the replacement without checking the consistency
   //               This can lead to inconsistent histograms and useless results
   //               or unexpected behaviour. But sometimes it might be the only
   //               way to change the histograms. If you use this option, you
   //               should ensure that the fPassedHistogram is replaced by a
   //               consistent one (with respect to rTotal) as well.

   TString option = opt;
   option.ToLower();

   Bool_t bReplace = option.Contains("f");

   if(!bReplace)
      bReplace = CheckConsistency(*fPassedHistogram,rTotal,"w");

   if(bReplace) {
      delete fTotalHistogram;
      Bool_t bStatus = TH1::AddDirectoryStatus();
      TH1::AddDirectory(kFALSE);
      fTotalHistogram = (TH1*)(rTotal.Clone());
      fTotalHistogram->SetNormFactor(0);
      TH1::AddDirectory(bStatus);

      if(fFunctions)
         fFunctions->Delete();

      //check whether histogram is filled with weights
      Double_t stattotal[TH1::kNstat];
      rTotal.GetStats(stattotal);
      //require: sum of weights == sum of weights^2
      if(TMath::Abs(stattotal[0]-stattotal[1]) > 1e-5)
         SetUseWeightedEvents();

      return true;
   }
   else
      return false;
}

//______________________________________________________________________________
void TEfficiency::SetUseWeightedEvents()
{
   SetBit(kUseWeights,true);
   fTotalHistogram->Sumw2();
   fPassedHistogram->Sumw2();
}

//______________________________________________________________________________
void TEfficiency::SetWeight(Double_t weight)
{
   //sets the global weight for this TEfficiency object
   //
   //Note: - weight has to be positive ( > 0)

   if(weight > 0)
      fWeight = weight;
   else
      Warning("SetWeight","invalid weight %.2lf",weight);
}

//______________________________________________________________________________
Double_t TEfficiency::Wilson(Int_t total,Int_t passed,Double_t level,Bool_t bUpper)
{
   //calculates the boundaries for the frequentist Wilson interval
   //
   //Input: - total : number of total events
   //       - passed: 0 <= number of passed events <= total
   //       - level : confidence level
   //       - bUpper: true  - upper boundary is returned
   //                 false - lower boundary is returned
   //
   //calculation:
   //Begin_Latex(separator='=',align='rl')
   // #alpha = 1 - #frac{level}{2}
   // #kappa = #Phi^{-1}(1 - #alpha,1) ... normal quantile function
   // mode = #frac{passed + #frac{#kappa^{2}}{2}}{total + #kappa^{2}}
   // #Delta = #frac{#kappa}{total + #kappa^{2}} * #sqrt{passed (1 - #frac{passed}{total}) + #frac{#kappa^{2}}{4}}
   // return = max(0,mode - #Delta) or min(1,mode + #Delta)
   //End_Latex

   Double_t alpha = (1.0 - level)/2;
   if (total == 0) return (bUpper) ? 1 : 0;
   Double_t average = ((Double_t)passed) / total;
   Double_t kappa = ROOT::Math::normal_quantile(1 - alpha,1);
   
   Double_t mode = (passed + 0.5 * kappa * kappa) / (total + kappa * kappa);
   Double_t delta = kappa / (total + kappa*kappa) * std::sqrt(total * average
                                                              * (1 - average) + kappa * kappa / 4);
   if(bUpper)
      return ((mode + delta) > 1) ? 1.0 : (mode + delta);
   else
      return ((mode - delta) < 0) ? 0.0 : (mode - delta);
}

//______________________________________________________________________________
const TEfficiency operator+(const TEfficiency& lhs,const TEfficiency& rhs)
{
   // addition operator
   //
   // adds the corresponding histograms:
   // lhs.GetTotalHistogram() + rhs.GetTotalHistogram()
   // lhs.GetPassedHistogram() + rhs.GetPassedHistogram()
   //
   // the statistic option and the confidence level are taken from lhs
   
   TEfficiency tmp(lhs);
   tmp += rhs;
   return tmp;
}

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