ROOT logo
/**
 * @file   DrawdNdeta.C
 * @author Christian Holm Christensen <cholm@nbi.dk>
 * @date   Wed Mar 23 14:07:10 2011
 * 
 * @brief  Script to visualise the dN/deta for pp and PbPb
 *
 * This script is independent of any AliROOT code - and should stay
 * that way.
 * 
 * The script is <i>very</i> long - sigh - the joy of drawing
 * things nicely in ROOT
 * 
 * @ingroup pwglf_forward_dndeta
 */
#include <TH1.h>
#include <TColor.h>
#include <THStack.h>
#include <TGraphErrors.h>
#include <TGraphAsymmErrors.h>
#include <TMultiGraph.h>
#include <TFile.h>
#include <TList.h>
#include <TString.h>
#include <TError.h>
#include <TSystem.h>
#include <TROOT.h>
#include <TMath.h>
#include <TCanvas.h>
#include <TPad.h>
#include <TStyle.h>
#include <TLegend.h>
#include <TLegendEntry.h>
#include <TLatex.h>
#include <TArrow.h>
#include <TImage.h>
#include <TRandom.h>
#include <TParameter.h>
#include <TGClient.h>
#include <fstream>
#include <iostream>
/** Systematic error color */
// #define SYSERR_COLOR kGray;
// #define SYSERR_COLOR kBlue-10
// #define SYSERR_COLOR kCyan-10
#define SYSERR_COLOR TColor::GetColor(220, 220, 255)
/** Systematic error style */
#define SYSERR_STYLE 1001

Double_t myFunc(Double_t* xp, Double_t* pp);


/**
 * Class to draw dN/deta results 
 * 
 * @ingroup pwglf_forward_tasks_dndeta
 * @ingroup pwglf_forward_dndeta
 */
struct dNdetaDrawer 
{
  enum EFlags { 
    kShowRatios     = 0x00001, 
    kShowLeftRight  = 0x00002, 
    kShowSysError   = 0x00004, 
    kShowRings      = 0x00008,
    kCutEdges       = 0x00010,
    kRemoveOuters   = 0x00020, 
    kUseFinalMC     = 0x00040,
    kUseEmpirical   = 0x00080,
    kForceMB        = 0x00100,
    kMirror         = 0x00200,
    kExport         = 0x00400, 
    kAddExec        = 0x00800,
    kOldFormat      = 0x01000,
    kVerbose        = 0x02000,
    kHiRes          = 0x04000,
    kExtraWhite     = 0x08000,
    kLogo           = 0x10000,
    kNoCentral      = 0x20000,
    kNoLabels       = 0x40000,
    kDefaultOptions = 0x1CE07
  };
  enum EOutFormat { 
    kPNG        = 0x1, 
    kPDF        = 0x2, 
    kROOT       = 0x4, 
    kScript     = 0x8,
    kAllFormats = 0xF
  };
  struct MarkerUtil 
  {
    /**
     * Marker styles 
     */
    enum { 
      kSolid        = 0x000, 
      kHollow       = 0x001, 
      kCircle       = 0x002,
      kSquare       = 0x004, 
      kUpTriangle   = 0x006, 
      kDownTriangle = 0x008, 
      kDiamond      = 0x00a,
      kCross        = 0x00c,
      kStar         = 0x00e
    };
    /** 
     * Get the marker style from option bits
     * 
     * @param bits Option bits 
     * 
     * @return Marker style 
     */
    static Int_t GetMarkerStyle(UShort_t bits)
    {
      Int_t  base   = bits & (0xFE);
      Bool_t hollow = bits & kHollow;
      switch (base) { 
      case kCircle:       return (hollow ? 24 : 20);
      case kSquare:       return (hollow ? 25 : 21);
      case kUpTriangle:   return (hollow ? 26 : 22);
      case kDownTriangle: return (hollow ? 32 : 23);
      case kDiamond:      return (hollow ? 27 : 33); 
      case kCross:        return (hollow ? 28 : 34); 
      case kStar:         return (hollow ? 30 : 29); 
      }
      return 1;
    }
    /** 
     * Get the marker option bits from a style 
     * 
     * @param style Style
     * 
     * @return option bits
     */
    static UShort_t GetMarkerBits(Int_t style)
    { 
      UShort_t bits = 0;
      switch (style) { 
      case 24: case 25: case 26: case 27: case 28: case 30: case 32: 
	bits |= kHollow; break;
      }
      switch (style) { 
      case 20: case 24: bits |= kCircle;       break;
      case 21: case 25: bits |= kSquare;       break;
      case 22: case 26: bits |= kUpTriangle;   break;
      case 23: case 32: bits |= kDownTriangle; break;
      case 27: case 33: bits |= kDiamond;      break;
      case 28: case 34: bits |= kCross;        break;
      case 29: case 30: bits |= kStar;         break;
      }
      return bits;
    }
    /** 
     * Flip an option bit 
     * 
     * @param style Style parameter
     * 
     * @return New style 
     */
    static Int_t FlipHollowStyle(Int_t style)
    {
      UShort_t bits = GetMarkerBits(style);
      Int_t    ret  = GetMarkerStyle(bits ^ kHollow);
      return ret;
    }    
  };
  
  /**
   * POD of data for range zooming 
   */
  struct RangeParam 
  {
    TAxis*       fMasterAxis; // Master axis 
    TAxis*       fSlave1Axis; // First slave axis 
    TVirtualPad* fSlave1Pad;  // First slave pad 
    TAxis*       fSlave2Axis; // Second slave axis 
    TVirtualPad* fSlave2Pad;  // Second slave pad 
  };
  //__________________________________________________________________
  /** 
   * Constructor 
   * 
   */
  dNdetaDrawer()
    : fOptions(kDefaultOptions),
      fFormats(kAllFormats),
      fShowOthers(0),        // Show other data
      // Settings 
      fRebin(0),             // Rebinning factor 
      fFwdSysErr(0.076),     // Systematic error in forward range
      fCenSysErr(0),         // Systematic error in central range 
      fTitle(""),            // Title on plot
      fBase(""),             // Optional base name of output files
      fClusterScale(""),     // Scaling of clusters to tracklets      
      // Read (or set) information 
      fTrigString(0),        // Trigger string (read, or set)
      fNormString(0),        // Normalisation string (read, or set)
      fSNNString(0),         // Energy string (read, or set)
      fSysString(0),         // Collision system string (read or set)
      fVtxAxis(0),           // Vertex cuts (read or set)
      fCentAxis(0),          // Centrality axis
      fCentMeth(0),          // Centrality axis
      fTriggerEff(1),        // Trigger efficency 
      fExtTriggerEff(false), // True if fTriggerEff was read 
      fCentMin(0),           // Least centrality to plot
      fCentMax(100),         // Largest centrality to plot
      // Resulting plots 
      fResults(0),           // Stack of results 
      fRatios(0),            // Stack of ratios 
      fLeftRight(0),         // Left-right asymmetry
      fOthers(0),            // Older data 
      fTriggers(0),          // Number of triggers
      fTruth(0),             // Pointer to truth 
    fRangeParam(0),        // Parameter object for range zoom 
    fEmpCorr(0)
  {
    fRangeParam = new RangeParam;
    fRangeParam->fMasterAxis = 0;
    fRangeParam->fSlave1Axis = 0;
    fRangeParam->fSlave1Pad  = 0;
    fRangeParam->fSlave2Axis = 0;
    fRangeParam->fSlave2Pad  = 0;

    TColor* sysErr = gROOT->GetColor(kSysErrColor);
    sysErr->SetAlpha(0.7);
  }
  /** 
   * Cpoy constructor 
   */
  dNdetaDrawer(const dNdetaDrawer&) {}
  /** 
   * Assignment operator
   * 
   * 
   * @return Reference to this object
   */
  dNdetaDrawer& operator=(const dNdetaDrawer&) { return *this; }

  //__________________________________________________________________
  /** 
   * Destructor 
   */
  virtual ~dNdetaDrawer()
  {
    if (fRatios  && fRatios->GetHists())  fRatios->GetHists()->Delete();
    if (fResults && fResults->GetHists()) fResults->GetHists()->Delete();

    if (fTrigString) { delete fTrigString; fTrigString = 0; }
    if (fSNNString)  { delete fSNNString;  fSNNString  = 0; }
    if (fSysString)  { delete fSysString;  fSysString  = 0; }
    if (fVtxAxis)    { delete fVtxAxis;    fVtxAxis    = 0; }
    if (fCentAxis)   { delete fCentAxis;   fCentAxis   = 0; }
    if (fCentMeth)   { delete fCentMeth;   fCentMeth   = 0; }
    if (fResults)    { delete fResults;    fResults    = 0; }
    if (fRatios)     { delete fRatios;     fRatios     = 0; }
    if (fOthers)     { delete fOthers;     fOthers     = 0; }
    if (fTriggers)   { delete fTriggers;   fTriggers   = 0; } 
    fRangeParam = 0;
  }

  //==================================================================
  void SetShowOthers(UInt_t others) { fShowOthers = others; }
  /** 
   * Set the rebinning factor 
   * 
   * @param x Rebinning factor (must be a divisor in the number of bins) 
   */
  void SetRebin(UShort_t x)       { fRebin = x; }
  //__________________________________________________________________
  /** 
   * Set the title of the plot
   * 
   * @param x Title
   */
  void SetTitle(TString x)        { fTitle = x; }
  //__________________________________________________________________
  /** 
   * Set the base name of the output files 
   * 
   * @param x Base name 
   */
  void SetBase(TString x) { fBase = x; }
  //__________________________________________________________________
  /** 
   * Set the systematic error in the forward region
   * 
   * @param e Systematic error in the forward region 
   */
  void SetForwardSysError(Double_t e=0) { fFwdSysErr = e; }
  //__________________________________________________________________
  /** 
   * Set the systematic error in the forward region
   * 
   * @param e Systematic error in the forward region 
   */
  void SetCentralSysError(Double_t e=0) { fCenSysErr = e; }
  /** 
   * Set the 'Final MC' correction file.  This is needed if the
   * secondary maps where produced using the old code
   * 
   * @param file Filename 
   */
  void SetFinalMC(const TString& file) { fFinalMC = file; }
  /** 
   * Set the file that contains the empirical correction.  This is
   * needed when the secondary maps was generated with an in-accurate
   * geometry, and when we're analysing data at nominal interaction
   * points
   * 
   * @param file Filename 
   */
  void SetEmpirical(const TString& file) { fEmpirical = file; }
  /* @} */
  //==================================================================  
  /** 
   * @{ 
   * @name Override settings from input 
   */
  /** 
   * Override setting from file 
   * 
   * @param sNN Center of mass energy per nucleon pair (GeV)
   */
  void SetSNN(UShort_t sNN) 
  {
    fSNNString = new TNamed("sNN", Form("%04dGeV", sNN));
    fSNNString->SetUniqueID(sNN);
  }
  //__________________________________________________________________
  /** 
   * Set the collision system 
   * - 1: pp 
   * - 2: PbPb
   * 
   * @param sys collision system
   */
  void SetSys(UShort_t sys)
  {
    fSysString = new TNamed("sys", (sys == 1 ? "pp" : 
				    sys == 2 ? "PbPb" : 
				    sys == 3 ? "pPb" : 
				    "unknown"));
    fSysString->SetUniqueID(sys);
  }
  //__________________________________________________________________
  /** 
   * Set the vertex range in centimeters 
   * 
   * @param vzMin Min @f$ v_z@f$
   * @param vzMax Max @f$ v_z@f$
   */
  void SetVertexRange(Double_t vzMin, Double_t vzMax) 
  {
    fVtxAxis = new TAxis(10, vzMin, vzMax);
    fVtxAxis->SetName("vtxAxis");
    fVtxAxis->SetTitle(Form("v_{z}#in[%+5.1f,%+5.1f]cm", vzMin, vzMax));
  }
  //__________________________________________________________________
  /** 
   * Set the centrality range in centimeters 
   * 
   * @param centMin Min @f$ v_z@f$
   * @param centMax Max @f$ v_z@f$
   */
  void SetCentralityRange(UShort_t centMin, UShort_t centMax) 
  {
    fCentMin = centMin;
    fCentMax = centMax;
  }
  //__________________________________________________________________
  /** 
   * Set the trigger mask (overrides what's in the file)
   * 
   * @param trig Trigger mask (0x1: INEL, 0x2: INEL>0, 0x4: NSD)
   */
  void SetTrigger(UShort_t trig)
  {
    fTrigString = new TNamed("trigString", (trig & 0x1 ? "MBOR" : 
					    trig & 0x2 ? "INEL>0" : 
					    trig & 0x4 ? "MBAND5" :
					    trig & 0x2000 ? "V0-AND" :
					    "unknown"));
    fTrigString->SetUniqueID(trig);
  }
  //__________________________________________________________________
  /** 
   * Set the trigger efficiency - if set, then scale result histograms 
   * by this factor 
   * 
   * @param eff @f$\varepsilon_{T}@f$ 
   */
  void SetTriggerEfficiency(Float_t eff)  
  { 
    fTriggerEff = eff; 
    fExtTriggerEff = false;
  }

  //==================================================================
  /** 
   * @{ 
   * @name Main steering functions 
   */
  void Run(const char* filename="forward_dndeta.root", 
	   const char* title="", 
	   const char* others="all",
	   const char* options="default",
	   const char* formats="all",
	   UShort_t    rebin=5,
	   Float_t     eff=0,
	   UShort_t    centMin=0, 
	   UShort_t    centMax=0, 
	   Float_t     vzMin=+999,
	   Float_t     vzMax=-999, 
	   const char* base="")
  {
    TString  ostr(others); ostr.ToUpper();
    UShort_t obits = 0x0;
    if (ostr.EqualTo("ALL")) obits = 0xf;
    else { 
      if (ostr.Contains("UA5"))   obits |= 0x1;
      if (ostr.Contains("CMS"))   obits |= 0x2;
      if (ostr.Contains("ALICE")) obits |= 0x4;
      if (ostr.Contains("WIP"))   obits |= 0x8;
    }
   
    TString fstr(options);
    UInt_t fbits  = 0;
    if (fstr.EqualTo("default", TString::kIgnoreCase)) fbits = kDefaultOptions;
    else {
      TObjArray* farr = fstr.Tokenize(" ,");
      TIter next(farr);
      TObjString* ftoken = 0;
      while ((ftoken = static_cast<TObjString*>(next()))) {
	TString& token = ftoken->String();
	token.ToLower();
	if      (token.BeginsWith("ratio"))         fbits |= kShowRatios;
        else if (token.BeginsWith("asym"))          fbits |= kShowLeftRight;
        else if (token.BeginsWith("left"))          fbits |= kShowLeftRight;
        else if (token.BeginsWith("syse"))          fbits |= kShowSysError;
        else if (token.BeginsWith("rings"))         fbits |= kShowRings;
        else if (token.BeginsWith("noedge"))        fbits |= kCutEdges;
        else if (token.BeginsWith("noout"))         fbits |= kRemoveOuters;
        else if (token.BeginsWith("finalmc"))       fbits |= kUseFinalMC;
        else if (token.BeginsWith("mb"))            fbits |= kForceMB;
        else if (token.BeginsWith("mirror"))        fbits |= kMirror;
        else if (token.BeginsWith("export"))        fbits |= kExport;
        else if (token.BeginsWith("exec"))          fbits |= kAddExec;
        else if (token.BeginsWith("old"))           fbits |= kOldFormat;
        else if (token.BeginsWith("verbose"))       fbits |= kVerbose;
        else if (token.BeginsWith("hires"))         fbits |= kHiRes;
        else if (token.BeginsWith("extraw"))        fbits |= kExtraWhite;
        else if (token.BeginsWith("logo"))          fbits |= kLogo;
        else if (token.BeginsWith("nocentr"))       fbits |= kNoCentral;
        else if (token.BeginsWith("nolabels"))      fbits |= kNoLabels;
        else if (token.BeginsWith("empirical"))  {
	  fbits |= kUseEmpirical;
	  TObjArray* parts=token.Tokenize("=");
	  if (parts->GetEntriesFast() > 1) 
	    SetEmpirical(parts->At(1)->GetName());
	  delete parts;
	}
      }  
      delete farr;
    }
    TString estr(formats); estr.ToUpper();
    UShort_t ebits = 0x0;
    if (ostr.EqualTo("ALL")) ebits = kAllFormats;
    else { 
      if (ostr.Contains("PNG"))  ebits |= kPNG;
      if (ostr.Contains("PDF"))  ebits |= kPDF;
      if (ostr.Contains("ROOT")) ebits |= kROOT;
      if (ostr.Contains("C"))    ebits |= kScript;
    }

    Run(filename, title, rebin, obits, fbits, 0, 0, 0, eff, 
	centMin, centMax, vzMin, vzMax, base, ebits);
  }
  /** 
   * Run the job
   * 
   * @param filename  Input file name  
   * @param title     Title to put on plot
   * @param rebin     Rebinning factor 
   * @param others    Which other to draw 
   * @param flags     Flags for the drawing 
   * @param sys       (optional) Collision system
   * @param sNN       (optional) Collision energy 
   * @param trg       (optional) Trigger 
   * @param eff       (optional) Efficiency 
   * @param centMin   (optional) Least centrality 
   * @param centMax   (optional) Largest centrality 
   * @param vzMin     (optional) Least @f$ IP_z@f$ 
   * @param vzMax     (optional) Largest @f$ IP_z@f$
   * @param base      Basename for output files
   * @param formats   Formats to export to 
   */
  void Run(const char* filename, 
	   const char* title, 
	   UShort_t    rebin, 
	   UShort_t    others=0x7, 
	   UInt_t      flags=kDefaultOptions,
	   UShort_t    sys=0,
	   UShort_t    sNN=0, 
	   UShort_t    trg=0, 
	   Float_t     eff=0, 
	   UShort_t    centMin=0, 
	   UShort_t    centMax=0, 
	   Float_t     vzMin=+999, 
	   Float_t     vzMax=-999,
	   const char* base="", 
	   UShort_t    formats=kAllFormats)
  {
    SetRebin(rebin);
    SetTitle(title);
    SetShowOthers(others);
    SetBase(base);
    // d.fClusterScale = "1.06 -0.003*x +0.0119*x*x";
    // Do the below if your input data does not contain these settings 
    if (sNN > 0) SetSNN(sNN);     // Collision energy per nucleon pair (GeV)
    if (sys > 0) SetSys(sys);     // Collision system (1:pp, 2:PbPB)
    if (trg > 0) SetTrigger(trg); // Collision trigger (1:INEL, 2:INEL>0, 4:NSD)
    if (eff > 0) SetTriggerEfficiency(eff); // Trigger efficiency
    if (vzMin < 999 && vzMax > -999) 
      SetVertexRange(vzMin,vzMax); // Collision vertex range (cm)
    SetCentralityRange(centMin,centMax); // Collision vertex range (cm)

    fOptions          = flags;
    fFormats          = formats;
    SetForwardSysError(flags & kShowSysError ? 0.076 : 0);
    SetFinalMC        (flags & kUseFinalMC ? "forward_dndetamc.root" : "");
    // "EmpiricalCorrection.root"
    SetEmpirical      (flags & kUseEmpirical ? fEmpirical.Data() : "");
    // SetBase(base);

    Double_t max = 0, rmax=0, amax=0;

    gStyle->SetPalette(1);

    // --- Open input file -------------------------------------------
    TFile* file = TFile::Open(filename, "READ");
    if (!file) { 
      Error("Run", "Cannot open %s", filename);
      return;
    }
    Info("Run", "Drawing results from %s", file->GetName());

    // --- Get forward list ------------------------------------------
    TList* forward = static_cast<TList*>(file->Get("ForwarddNdetaResults"));
    if (!forward) { 
      Error("Run", "Couldn't find list ForwarddNdetaResults");
      return;
    }
    TList* sums = static_cast<TList*>(file->Get("ForwarddNdetaSums"));
    if (!sums) { 
      Error("Run", "Couldn't find list ForwarddNdetaSums");
      return;
    }
    TParameter<bool>* p = 
      static_cast<TParameter<bool>*>(sums->FindObject("empirical"));
    if (p && p->GetVal() && !fEmpirical.IsNull()) {
      Warning("Run", "Empirical correction already applied");
      fEmpirical = "__task__";
    }
    // --- Get information on the run --------------------------------
    FetchInformation(forward);

    // --- Print settings --------------------------------------------
    Info("Run", "Settings for the drawer:\n"
	 "   Show ratios:                      %5s\n"
	 "   Show Left/right:                  %5s\n"
	 "   Show rings:                       %5s\n"
	 "   Cut edges when rebinning:         %5s\n"
	 "   Remove outer rings:               %5s\n"
	 "   Force minimum bias:               %5s\n"
	 "   Mirror to un-covered regions:     %5s\n"
	 "   Export to file:                   %5s\n"
	 "   Add Zoom code:                    %5s\n"
	 "   Assume old format:                %5s\n"
	 "   Be verbose:                       %5s\n"
	 "   Hi-resolution plot:               %5s\n"
	 "   Extra whitespace:                 %5s\n"
	 "   Show logo:                        %5s\n"
	 "   Show clusters:                    %5s\n"
	 "   Show y-axis labels:               %5s\n"
	 "   Show other results:               0x%03x\n"
	 "   Rebinning factor:                 %5d\n"
	 "   Forward systematic error:         %5.1f%%\n"
	 "   Central systematic error:         %5.1f%%\n"
	 "   Trigger efficiency:               %5.1f%%\n"
	 "   Title on plot:                    %s\n"
	 "   Scaling of clusters to tracklets: %s\n"
	 "   Final MC correction file:         %s\n"
	 "   Empirical correction file:        %s",
	 ((fOptions & kShowRatios)    ? "yes" : "no"), 
	 ((fOptions & kShowLeftRight) ? "yes" : "no"),
	 ((fOptions & kShowRings)     ? "yes" : "no"),
	 ((fOptions & kCutEdges)      ? "yes" : "no"),
	 ((fOptions & kRemoveOuters)  ? "yes" : "no"),
	 ((fOptions & kForceMB)       ? "yes" : "no"),
	 ((fOptions & kMirror)        ? "yes" : "no"),
	 ((fOptions & kExport)        ? "yes" : "no"), 
	 ((fOptions & kAddExec)       ? "yes" : "no"), 
	 ((fOptions & kOldFormat)     ? "yes" : "no"), 
	 ((fOptions & kVerbose)       ? "yes" : "no"), 
	 ((fOptions & kHiRes)         ? "yes" : "no"), 
	 ((fOptions & kExtraWhite)    ? "yes" : "no"), 
	 ((fOptions & kLogo)          ? "yes" : "no"), 
	 ((fOptions & kNoCentral)     ? "no"  : "yes"),
	 ((fOptions & kNoLabels)      ? "no"  : "yes"),
	 fShowOthers, 
	 fRebin, 
	 (100*fFwdSysErr), 
	 (100*fCenSysErr), 
	 (100*fTriggerEff),
	 fTitle.Data(), 
	 fClusterScale.Data(), 
	 fFinalMC.Data(), 
	 fEmpirical.Data());

    // --- Set the macro pathand load other data script --------------
    TString savPath(gROOT->GetMacroPath());
    gROOT->SetMacroPath(Form("%s:$(ALICE_ROOT)/PWGLF/FORWARD/analysis2",
			     gROOT->GetMacroPath()));
    // Always recompile 
    if (!gROOT->GetClass("RefData"))
      gROOT->LoadMacro("OtherData.C+");
    gROOT->SetMacroPath(savPath);

    Bool_t useCen = !(fOptions & kNoCentral);
    // --- Get the central results -----------------------------------
    TList* clusters = 0;
    if (useCen) {
      clusters = static_cast<TList*>(file->Get("CentraldNdetaResults"));
      if (!clusters) Warning("Run", "Couldn't find list CentraldNdetaResults");
    }

    // --- Get the central results -----------------------------------
    TList* mcTruth = static_cast<TList*>(file->Get("MCTruthdNdetaResults"));
    if (!mcTruth) Warning("Run", "Couldn't find list MCTruthdNdetaResults");

    // --- Make our containtes ---------------------------------------
    fResults   = new THStack("results", "Results");
    fRatios    = new THStack("ratios",  "Ratios");
    fLeftRight = new THStack("asymmetry", "Left-right asymmetry");
    fOthers    = new TMultiGraph();

    // --- Try to open the final MC file, and find relevant lists ----
    TList* forwardMC = 0;
    // TList* centralMC = 0;
    if (!fFinalMC.IsNull()) { 
      TFile* finalMC = TFile::Open(fFinalMC, "READ");
      if (!finalMC) { 
	Warning("Run", "Failed to open file %s for final MC corrections", 
		fFinalMC.Data());
      }
      else { 
	forwardMC = static_cast<TList*>(finalMC->Get("ForwarddNdetaResults"));
	if (!forwardMC) 
	  Warning("Run","Couldn't find list ForwarddNdetaResults for final MC");
#if 0
	centralMC = static_cast<TList*>(finalMC->Get("CentradNdetalResults"));
	if (!centralMC) 
	  Warning("Run","Couldn't find list CentraldNdetaResults for final MC");
#endif
      }
    }
    if (!forwardMC) fFinalMC = "";

    // --- Try to get the emperical correction -----------------------
    TObject* fwdEmp = 0;
    TObject* cenEmp = 0;
    if (!fEmpirical.IsNull() && !fEmpirical.EqualTo("__task__")) {
      TUrl empUrl(fEmpirical);
      TFile* empirical = TFile::Open(empUrl.GetUrl(), "READ");
      if (!empirical) { 
	Warning("Run", "couldn't open empirical correction file: %s",
		empUrl.GetUrl());
	fEmpirical = "";
      }
      else {
	const char* empPath = empUrl.GetAnchor();
	TObject*    fwdObj  = empirical->Get(Form("Forward/%s", empPath));
	TObject*    cenObj  = empirical->Get(Form("Central/%s", empPath));
	if (!(fwdObj &&
	      (fwdObj->IsA()->InheritsFrom(TH1::Class()) || 
	       fwdObj->IsA()->InheritsFrom(TGraphAsymmErrors::Class())))) { 
	  Warning("Run", "Didn't get the object Forward/%s from %s", 
		  empPath, empUrl.GetUrl());
	  fEmpirical = "";
	}
	if (useCen && !(cenObj &&
			(cenObj->IsA()->InheritsFrom(TH1::Class()) || 
	   cenObj->IsA()->InheritsFrom(TGraphAsymmErrors::Class())))) { 
	  Warning("Run", "Didn't get the object Central/%s from %s", 
		  empPath, empUrl.GetUrl());
	  fEmpirical = "";
	}
	else {
	  fwdEmp = fwdObj;
	  cenEmp = fwdObj;
	}
      }
    }
    if (!fEmpCorr && !fEmpirical.EqualTo("__task__")) 
      fEmpirical = "";

    // --- Loop over input data --------------------------------------
    TObjArray truths;
    FetchTopResults(mcTruth,  0, 0, "MCTruth", max, rmax, amax,truths);
    TObjArray* fwdA = FetchTopResults(forward, forwardMC, fwdEmp, "Forward", 
				   max, rmax, amax,truths);
    TObjArray* cenA = FetchTopResults(clusters, 0, cenEmp, "Central", 
				   max, rmax, amax,truths);

    // --- Get trigger information -----------------------------------
    // TList* sums = static_cast<TList*>(file->Get("ForwardSums"));
    if (sums) {
      TList* all = (fOptions & kOldFormat ? sums : 
		    static_cast<TList*>(sums->FindObject("all")));
      if (all) {
	fTriggers = FetchHistogram(all, "triggers");
	if (!fTriggers) all->ls();
      }
      else  {
	Warning("Run", "List all not found in ForwardSums");
	sums->ls();
      }
    }
    else { 
      Warning("Run", "No ForwardSums directory found in %s", file->GetName());
      file->ls();
    }
    
    // --- Check our stacks ------------------------------------------
    if (!fResults->GetHists() || 
	fResults->GetHists()->GetEntries() <= 0) { 
      Error("Run", "No histograms in result stack!");
      return;
    }
    if (!fOthers->GetListOfGraphs() || 
	fOthers->GetListOfGraphs()->GetEntries() <= 0) { 
      Warning("Run", "No other data found - disabling that");
      fShowOthers = 0;
    }
    if (!fRatios->GetHists() || 
	fRatios->GetHists()->GetEntries() <= 0) { 
      Warning("Run", "No ratio data found - disabling that");
      // fRatios->ls();
      fOptions &= ~kShowRatios;
    }
    if (!fLeftRight->GetHists() || 
	fLeftRight->GetHists()->GetEntries() <= 0) { 
      Warning("Run", "No left/right data found - disabling that");
      // fLeftRight->ls();
      fOptions &= ~kShowLeftRight;
    }
    if (fFwdSysErr > 0) { 
      if (fCenSysErr <= 0) fCenSysErr = fFwdSysErr;
      for (Int_t i = 0; i < fwdA->GetEntriesFast(); i++) {
	TH1* fwd = static_cast<TH1*>(fwdA->At(i));
	TH1* cen = (cenA ? static_cast<TH1*>(cenA->At(i)) : 0);
	CorrectForward(fwd);
	CorrectCentral(cen);
	Double_t low, high;
	TH1* tmp = Merge(cen, fwd, low, high);
	TF1* f   = FitMerged(tmp, low, high);
	MakeSysError(tmp, cen, fwd, f);
	delete f;

	if (fOptions & kNoCentral) { 
	  // Split Sys error into two histograms 
	  const char* nme  = tmp->GetName();
	  TH1* tmpp = static_cast<TH1*>(tmp->Clone(Form("%s_a", nme)));
	  tmp->SetName(Form("%s_c", nme));
	  for (Int_t k = 1; k <= tmp->GetNbinsX(); k++) { 
	    Double_t x = tmp->GetXaxis()->GetBinCenter(k);
	    TH1* tmppp = (x < 0 ? tmpp : tmp);
	    tmppp->SetBinError(k, 0);
	    tmppp->SetBinContent(k, 0);
	  }
	  fResults->GetHists()->AddFirst(tmpp, "e5");
	}

	if (fOptions & kVerbose) 
	  Info("", "Adding systematic error histogram %s", tmp->GetName());
	fResults->GetHists()->AddFirst(tmp, "e5");

	if (!(fOptions & kMirror)) continue;

	TH1* tmp2 = Symmetrice(tmp);
	tmp2->SetFillColor(tmp->GetFillColor());
	tmp2->SetFillStyle(tmp->GetFillStyle());
	tmp2->SetMarkerStyle(tmp->GetMarkerStyle());
	tmp2->SetLineWidth(tmp->GetLineWidth());
	fResults->GetHists()->AddFirst(tmp2, "e5");
	fResults->Modified();
      }
    }
    delete fwdA;
    delete cenA;
    
    // --- Close the input file --------------------------------------
    file->Close();

    

    // --- Plot results ----------------------------------------------
    Plot(max, rmax, amax);
  }

  //__________________________________________________________________
  /** 
   * Fetch the information on the run from the results list
   * 
   * @param results  Results list
   */
  void FetchInformation(const TList* results)
  {
    if (!fTrigString) 
      fTrigString = static_cast<TNamed*>(results->FindObject("trigger"));
    if (!fNormString) 
      fNormString = static_cast<TNamed*>(results->FindObject("scheme"));
    if (!fSNNString) 
      fSNNString  = static_cast<TNamed*>(results->FindObject("sNN"));
    if (!fSysString) 
      fSysString  = static_cast<TNamed*>(results->FindObject("sys"));
    if (!fVtxAxis)
      fVtxAxis    = static_cast<TAxis*>(results->FindObject("vtxAxis"));
    if (!fCentAxis) {
      TObject* cO = results->FindObject("centAxis");
      if (cO) {
	if (cO->IsA()->InheritsFrom(TH1::Class())) {
	  TH1* cH     = static_cast<TH1*>(cO);
	  fCentAxis   = cH->GetXaxis();
	}
	else if (cO->IsA()->InheritsFrom(TAxis::Class())) 
	  fCentAxis   = static_cast<TAxis*>(cO);
      }
    }
    if (!fCentMeth) 
      fCentMeth = results->FindObject("centEstimator");

    if (fTriggerEff < 0) { 
      // Allow complete overwrite by passing negative number 
      SetTriggerEfficiency(TMath::Abs(fTriggerEff));
    }
    else if (fTriggerEff <= 0 || TMath::Abs(1-fTriggerEff)<1e-6) {
      TParameter<double>* eff = 
	static_cast<TParameter<double>*>(results->FindObject("triggerEff"));
      if (eff) {
	fTriggerEff = eff->GetVal();
	fExtTriggerEff = true;
	Info("FetchInformation", "External trigger efficicency: %5.3f",
	     fTriggerEff);
      }
      if (fTriggerEff <= 0) SetTriggerEfficiency(1);
    }

    TNamed* options = static_cast<TAxis*>(results->FindObject("options"));
    if (!fTrigString) fTrigString = new TNamed("trigger", "unknown");
    if (!fNormString) fNormString = new TNamed("scheme", "unknown");
    if (!fSNNString)  fSNNString  = new TNamed("sNN", "unknown");
    if (!fSysString)  fSysString  = new TNamed("sys", "unknown");
    if (!fVtxAxis) { 
      fVtxAxis    = new TAxis(1,0,0);
      fVtxAxis->SetName("vtxAxis");
      fVtxAxis->SetTitle("v_{z} range unspecified");
    }
    if (fCentAxis) {
      TArrayD  bins(fCentAxis->GetNbins()+1);
      Int_t    nBins = 0;
      Double_t high  = -1;
      for (Int_t i = 1; i <= fCentAxis->GetNbins(); i++) {
	Double_t binLow  = fCentAxis->GetBinLowEdge(i);
	Double_t binHigh = fCentAxis->GetBinUpEdge(i);
	if (binLow  < fCentMin-.5) continue;
	if (binHigh > fCentMax+.5) continue;
	high = binHigh;
	bins[nBins] = binLow;
	nBins++;
      }
      bins[nBins] = high;
      fCentAxis->Set(nBins, bins.GetArray());
    }
	
    if (fTrigString) { 
      UInt_t mask = 0x200f & fTrigString->GetUniqueID();
      if      (mask == 0x2)      fTrigString->SetTitle("INEL>0");
      else if (fTriggerEff != 1) {
	if      (mask == 0x1)    fTrigString->SetTitle("INEL");
	else if (mask == 0x2000) fTrigString->SetTitle("NSD");
	else if (mask == 0x4)    fTrigString->SetTitle("NSD");
      }
    }

    if (true /*fOptions & kVerbose*/) {
      TString centTxt("none");
      if (fCentAxis) { 
	Int_t nCent = fCentAxis->GetNbins();
	centTxt = Form("%d bins", nCent);
	for (Int_t i = 0; i <= nCent; i++) 
	  centTxt.Append(Form("%c%d", i == 0 ? ' ' : '-', 
			      int(fCentAxis->GetXbins()->At(i))));
      }
      Info("FetchInformation", 
	   "Initialized for\n"
	   "   Trigger:       %-30s  (0x%x)\n"
	   "   Efficiency:    %-6.4f\n"
	   "   sqrt(sNN):     %-30s  (%dGeV)\n"
	   "   System:        %-30s  (%d)\n"
	   "   Vz range:      %-30s  (%f,%f)\n"
	   "   Normalization: %-30s  (%d)\n"
	   "   Centrality:    %s\n"
	   "   Options:       %s",
	   fTrigString->GetTitle(), fTrigString->GetUniqueID(), 
	   fTriggerEff,
	   fSNNString->GetTitle(),  fSNNString->GetUniqueID(), 
	   fSysString->GetTitle(),  fSysString->GetUniqueID(), 
	   fVtxAxis->GetTitle(), fVtxAxis->GetXmin(), fVtxAxis->GetXmax(),
	   fNormString->GetTitle(), fNormString->GetUniqueID(),
	   centTxt.Data(), (options ? options->GetTitle() : "none"));
    }
    if (fSysString->GetUniqueID() == 3) {
      Info("FetchInformation", "Left/Right assymmetry, mirror, and systematic "
	   "errors explicitly disabled for pPb");
      fOptions   &= ~kShowLeftRight;
      fOptions   &= ~kMirror;
      fFwdSysErr =  0;
      fCenSysErr =  0;
    }
  }
  //__________________________________________________________________
  TMultiGraph* FetchOthers(UShort_t centLow, UShort_t centHigh)
  {
    TMultiGraph* thisOther = 0;
    if (fShowOthers == 0) return 0;

    UShort_t sys   = (fSysString  ? fSysString->GetUniqueID() : 0);
    UShort_t trg   = (fTrigString ? fTrigString->GetUniqueID() : 0);
    UShort_t snn   = (fSNNString  ? fSNNString->GetUniqueID() : 0);
    if (centLow < centHigh) {
      // Possibly modify trg according to method 
    }
    Long_t   ret   = 
      gROOT->ProcessLine(Form("RefData::GetData(%d,%d,%d,%d,%d,%d);",
			      sys,snn,trg,centLow,centHigh,fShowOthers));
    if (!ret) {
      Warning("", "RefData::GetData(%d,%d,0x%x,%d,%d,0x%x);",
	      sys,snn,trg,centLow,centHigh,fShowOthers);
      Warning("FetchOthers", 
	      "No other data for %s %s %s %3d%%-%3d%% central (0x%x)", 
	      fSysString  ? fSysString->GetTitle()  : "unknown", 
	      fTrigString ? fTrigString->GetTitle() : "unknown", 
	      fSNNString  ? fSNNString->GetTitle()  : "unknown", 
	      centLow, centHigh, fShowOthers);
      return 0;
    }

    thisOther = reinterpret_cast<TMultiGraph*>(ret);    
    return thisOther;
  }
  //__________________________________________________________________
  /** 
   * Get the results from the top-level list (MC, SPD, FMD)
   * 
   * @param list    List 
   * @param mcList  List of histograms from MC
   * @param empCorr Emperical correction if any
   * @param name    name 
   * @param max     On return, maximum of data 
   * @param rmax    On return, maximum of ratios
   * @param amax    On return, maximum of left-right comparisons
   * @param truths  List of MC truths to compare to. 
   *
   * @return Array of results
   */
  TObjArray* 
  FetchTopResults(const TList*  list, 
		  const TList*  mcList,
		  TObject*      empCorr,
		  const char*   name, 
		  Double_t&     max,
		  Double_t&     rmax,
		  Double_t&     amax,
		  TObjArray&    truths)
  {
    if (!list) return 0;
    UShort_t   n = HasCent() ? fCentAxis->GetNbins() : 1;
    // // Info("FetchTopResults","got %d centrality bins", n);
    // if (n == 0) {
    //   TH1* h  = FetchOne(list, mcList, empCorr, name, "all",
    // 			 FetchOthers(0,0), -1000, 0, 
    // 			 max, rmax, amax, truths);
    //   if (!h) return 0;
    //   TObjArray* a = new TObjArray;
    //   // Info("FetchTopResults", "Adding %s to result stack", h->GetName());
    //   a->AddAt(h, 0);
    //   return a;
    // }
    
    TObjArray* a = new TObjArray;
    truths.Expand(n);
    for (UShort_t i = 0; i < n; i++) { 
      UShort_t centLow  = 0;
      UShort_t centHigh = 0;
      TString  lname    = "all";
      Int_t    col      = -1000;
      TString  centTxt  = "";
      if (HasCent()) {
	centLow  = fCentAxis->GetBinLowEdge(i+1);
	centHigh = fCentAxis->GetBinUpEdge(i+1);
	lname    = Form("cent%03d_%03d", centLow, centHigh);
	col      = GetCentralityColor(i+1);
        centTxt  = Form("%3d%%-%3d%% central", centLow, centHigh);
      }
      TH1* tt = static_cast<TH1*>(truths.At(i));
      TH1* ot = tt;
      TH1* h  = FetchOne(list, mcList, empCorr, name, lname,
			 FetchOthers(centLow,centHigh), col, 
			 centTxt.Data(), max, rmax, amax, tt);
      if (!h) continue;

      if (tt != ot) { 
	truths.AddAt(tt, i);
      }
      // Info("FetchTopResults", "Adding %p to result stack", h);
      a->AddAt(h, i);
    }
    if (a->GetEntries() <= 0) {
      delete a;
      a = 0;
    }
    return a;
  } 
  //__________________________________________________________________
  /** 
   * Steer retrieval one centrality bin results
   * 
   * @param list          Input list
   * @param mcList        Possible MC list
   * @param empCorr       Possible empirical correction
   * @param name          Name of bing 
   * @param folderName    What sub-folder to get 
   * @param others        What else to plot 
   * @param col           Color 
   * @param txt           Centrality text 
   * @param max           Current maximum, on return new maximum 
   * @param rmax          Current range maximum, on return new maximum 
   * @param amax          Current A maximum, on return new maximum 
   * @param truth         Possible MC truth histogram 
   * 
   * @return 
   */
  TH1* FetchOne(const TList*  list, 
		const TList*  mcList,
		TObject*      empCorr,
		const char*   name, 
		const char*   folderName,
		TMultiGraph*  others, 
		Int_t         col,
		const char*   /* txt */,
		Double_t&     max,
		Double_t&     rmax,
		Double_t&     amax,
		TH1*&         truth)
  {
    TList* folder = (fOptions & kOldFormat ? const_cast<TList*>(list) :
		     static_cast<TList*>(list->FindObject(folderName)));
    if (!folder) {
      Error("FetchOne", "Couldn't find list '%s' in %s", 
	    folderName, list->GetName());
      return 0;
    }
    TList* mcFolder = 0;
    if (mcList) {
      mcFolder = static_cast<TList*>(mcList->FindObject(folderName));
      if (!mcFolder) 
	Warning("FetchOne", 
		"Didn't find the list '%s' in %s for final MC correction", 
		folderName, mcList->GetName());
    }
    if (fOptions & kVerbose) {
      TObject* normCalc = folder->FindObject("normCalc");
      if (normCalc) 
	Info("FetchOne", "%s:\n%s", 
	     folderName, normCalc->GetTitle());
    }
    TH1* h = FetchCentResults(folder, mcFolder, empCorr, name, 
			      others, col, folderName, max, rmax, amax, truth);
    return h;
  }
  //__________________________________________________________________
  /** 
   * Fetch results for a particular centrality bin
   * 
   * @param list       List 
   * @param mcList     List of MC results
   * @param empCorr    Emperical correction if any 
   * @param name       Name 
   * @param thisOther  Other graphs 
   * @param color      Color 
   * @param centTxt    Centrality text
   * @param max        On return, data maximum
   * @param rmax       On return, ratio maximum 
   * @param amax       On return, left-right maximum 
   * @param truth      MC truth to compare to or possibly update
   *
   * @return Histogram of results 
   */
  TH1* FetchCentResults(const TList*  list, 
			const TList*  mcList, 
			TObject*      empCorr,
			const char*   name, 
			TMultiGraph*  thisOther,
			Int_t         color,
			const char*   centTxt,
			Double_t&     max,
			Double_t&     rmax,
			Double_t&     amax, 
			TH1*&         truth)
  {
    
    TH1* dndeta      = FetchHistogram(list, Form("dndeta%s", name));
    TH1* dndetaMC    = FetchHistogram(list, Form("dndeta%sMC", name));
    TH1* dndetaTruth = FetchHistogram(list, "dndetaTruth");
    // Info("", "dN/deta truth from %s: %p", list->GetName(), dndetaTruth);
    // Info("", "dN/deta truth from external: %p", truth);

    if (mcList && FetchHistogram(mcList, "finalMCCorr")) 
      Warning("FetchCentResults", "dNdeta already corrected for final MC");
    else 
      CorrectFinalMC(dndeta, mcList);
      
    CorrectEmpirical(dndeta, empCorr);
    CorrectTriggerEff(dndeta);
    CorrectTriggerEff(dndetaMC);

    TH1* dndetaSym   = 0;
    TH1* dndetaMCSym = 0;
    SetAttributes(dndeta,     color);
    SetAttributes(dndetaMC,   HasCent() ? color : color+2);
    SetAttributes(dndetaTruth,color);
    SetAttributes(dndetaSym,  color);
    SetAttributes(dndetaMCSym,HasCent() ? color : color+2);
    if (dndetaMC && HasCent()) 
      dndetaMC->SetMarkerStyle(dndetaMC->GetMarkerStyle()+2);
    if (dndetaMCSym && HasCent()) 
      dndetaMCSym->SetMarkerStyle(dndetaMCSym->GetMarkerStyle()+2);
    if (dndetaTruth && HasCent()) {
      dndetaTruth->SetMarkerStyle(34);
      dndetaTruth->SetMarkerColor(kYellow-1);
    }
    if (dndetaTruth) { 
      dndetaTruth->SetLineColor(kBlack); 
      dndetaTruth->SetFillColor(kBlack); 
      dndetaTruth->SetFillStyle(3002); 
      // dndetaTruth->SetLineColor(kBlack); 
    }
    ModifyTitle(dndeta,     centTxt);
    ModifyTitle(dndetaMC,   centTxt);
    ModifyTitle(dndetaTruth,centTxt);
    ModifyTitle(dndetaSym,  centTxt);
    ModifyTitle(dndetaMCSym,centTxt);


    max = TMath::Max(max, AddHistogram(fResults, dndetaTruth, "e5"));
    max = TMath::Max(max, AddHistogram(fResults, dndetaMC,    dndetaMCSym));
    max = TMath::Max(max, AddHistogram(fResults, dndeta,      dndetaSym));

    if (dndetaTruth) {
      truth = dndetaTruth;
    }
    else {
      if ((fOptions & kShowRings)) {
	THStack* rings = static_cast<THStack*>(list->FindObject("dndetaRings"));
	if (rings) { 
	  TIter next(rings->GetHists());
	  TH1*  hist = 0;
	  while ((hist = static_cast<TH1*>(next()))) 
	    max = TMath::Max(max, AddHistogram(fResults, hist));
	}
      } // If show rings
      // Info("FetchCentResults", "Got %p, %p, %p from %s with name %s, max=%f",
      //      dndeta, dndetaMC, dndetaTruth, list->GetName(), name, max);
      
      if ((fOptions & kShowLeftRight)) {
	fLeftRight->Add(Asymmetry(dndeta,    amax));
	fLeftRight->Add(Asymmetry(dndetaMC,  amax));
      }
      
      if (thisOther) {
	TIter next(thisOther->GetListOfGraphs());
	TGraph* g = 0;
	while ((g = static_cast<TGraph*>(next()))) {
	  fRatios->Add(Ratio(dndeta,    g, rmax));
	  fRatios->Add(Ratio(dndetaSym, g, rmax));
	  SetAttributes(g, color);
	  ModifyTitle(g, centTxt);
	  if (!fOthers->GetListOfGraphs() || 
	      !fOthers->GetListOfGraphs()->FindObject(g->GetName())) {
	    max = TMath::Max(max,TMath::MaxElement(g->GetN(), g->GetY()));
	    fOthers->Add(g);
	  }
	}
	// fOthers->Add(thisOther);
      } // if others for this 
    } // if not truth 
    if (dndetaMC) { 
      fRatios->Add(Ratio(dndeta,    dndetaMC,    rmax));
      fRatios->Add(Ratio(dndetaSym, dndetaMCSym, rmax));
    }
    if (truth) {
      Info("", "Forming ratio to truth:\n\t%s\n\t%s",
	   dndeta->GetName(), 
	   truth->GetName());
      fRatios->Add(Ratio(dndeta,      truth, rmax));
      fRatios->Add(Ratio(dndetaSym,   truth, rmax));
    }
    return dndeta;
  }
  //__________________________________________________________________
  void CorrectFinalMC(TH1* dndeta, const TList* mcList)
  {
    if (!dndeta) return;
    if (!mcList) return;

    TH1* dndetaMC    = FetchHistogram(mcList, dndeta->GetName());
    TH1* dndetaTruth = FetchHistogram(mcList, "dndetaTruth");
    if (!dndetaMC || !dndetaTruth) return;
    
    TH1* corr = static_cast<TH1*>(dndetaMC->Clone("finalMCCorr"));
    corr->Divide(dndetaTruth);
    
    Info("CorrectFinalMC", "Correcting dN/deta with final MC correction");
    dndeta->Divide(corr);
  }
  //__________________________________________________________________
  void CorrectEmpirical(TH1* dndeta, TObject* empObj) 
  {
    if (!dndeta) return;
    if (!empObj) return;
   
    
    if (empObj->IsA()->InheritsFrom(TGraphAsymmErrors::Class())) {
      Info("CorrectEmpirical", "Doing empirical correction of dN/deta");
      TGraphAsymmErrors* empCorr = static_cast<TGraphAsymmErrors*>(empObj);
      TAxis* xAxis = dndeta->GetXaxis();
      for (Int_t i = 1; i <= xAxis->GetNbins(); i++) {
	Double_t x = xAxis->GetBinCenter(i);
	Double_t y = dndeta->GetBinContent(i);
	Double_t c = empCorr->Eval(x);
	dndeta->SetBinContent(i, y / c);
      }
    }
    else if (empObj->IsA()->InheritsFrom(TH1::Class())) {
      Info("CorrectEmpirical", "Doing empirical correction of dN/deta");
      TH1* empCorr = static_cast<TH1*>(empObj);
      dndeta->Divide(empCorr);
    }
    else { 
      Warning("CorrectEmpirical", 
	      "Don't know how to apply a %s as an empirical correction",
	      empObj->IsA()->GetName());
    }
  }
  //__________________________________________________________________
  void CorrectTriggerEff(TH1* dndeta)
  {
    if (fExtTriggerEff) return;
    if (!dndeta) return;
    if (fTriggerEff <= 0) return; //  || fTriggerEff >= 1) return;
    Info("CorrectTriggerEff", "Correcting with trigger efficiency %5.3f",
	 fTriggerEff);
    dndeta->Scale(fTriggerEff);
  }
  //__________________________________________________________________
  /** 
   * Plot the results
   * @param max        Max value 
   * @param rmax       Maximum diviation from 1 of ratios 
   * @param amax       Maximum diviation from 1 of asymmetries 
   */
  void Plot(Double_t     max, 
	    Double_t     rmax,
	    Double_t     amax)
  {
    gStyle->SetOptTitle(0);
    gStyle->SetTitleFont(kFont, "xyz");
    gStyle->SetLabelFont(kFont, "xyz");
    
    Int_t    h  = (gROOT->IsBatch() ? 
		   ((fOptions & kHiRes) ? 1600 : 900) :
		   gClient->GetDisplayHeight());
    Int_t    w  = h; // h / TMath::Sqrt(2);
    Double_t y1 = 0;
    Double_t y2 = 0;
    Double_t y3 = 0;
    if (!(fOptions & kShowRatios))    w  *= 1.3;
    else                 y1 =  0.3;
    if (!(fOptions & kShowLeftRight)) w  *= 1.3;
    else { 
      Double_t y11 = y1;
      y1 = (y11 > 0.0001 ? 0.4 : 0.2);
      y2 = (y11 > 0.0001 ? 0.2 : 0.2);
    }
    TCanvas* c = new TCanvas("Results", "Results", w, h);
    c->SetFillColor(0);
    c->SetBorderSize(0);
    c->SetBorderMode(0);

    Double_t s = Float_t(h) / 900;

    PlotResults(max, y1, s);
    c->cd();

    PlotRatios(rmax, y2, y1);
    c->cd( );

    PlotLeftRight(amax, y3, y2);
    c->cd();

    
    Int_t   vMin = fVtxAxis->GetXmin();
    Int_t   vMax = fVtxAxis->GetXmax();    
    TString trg(fTrigString->GetTitle());
    Int_t   nev  = 0;
    if (fTriggers) nev = fTriggers->GetBinContent(1);
    if (HasCent()) trg = "CENT";
    trg          = trg.Strip(TString::kBoth);
    trg.ReplaceAll(" ", "_");
    trg.ReplaceAll(">", "Gt");
    trg.ReplaceAll("&", "AND");
    trg.ReplaceAll("|", "OR");
    if (fBase.IsNull()) 
      fBase = "dndeta_<sys>_<snn>_<trig>_<ipmin><ipmax>cm_<nev>ev";
    fBase.ReplaceAll("<sys>",   fSysString->GetTitle());
    fBase.ReplaceAll("<snn>",   fSNNString->GetTitle());
    fBase.ReplaceAll("<trig>",  trg.Data());
    fBase.ReplaceAll("<ipmin>", Form("%c%02d",vMin<0?'m':'p',TMath::Abs(vMin)));
    fBase.ReplaceAll("<ipmax>", Form("%c%02d",vMax<0?'m':'p',TMath::Abs(vMax)));
    fBase.ReplaceAll("<nev>",   Form("%09d",  nev));
    if ((fFormats & kPNG))   c->SaveAs(Form("%s.png",  fBase.Data()));
    if ((fFormats & kROOT))  c->SaveAs(Form("%s.root", fBase.Data()));
    if ((fFormats & kScript))c->SaveAs(Form("%s.C",    fBase.Data()));
    if ((fFormats & kPDF))   c->SaveAs(Form("%s.pdf",  fBase.Data()));
    if (fOptions & kExport) {
      TString exp(fBase);
      exp.ReplaceAll("dndeta", "export");
      exp.ReplaceAll("dNdeta", "export");
      Export(exp);
    }
  }
  //__________________________________________________________________
  /** 
   * Plot the title on a pad 
   * 
   * @param p       Pad to draw in
   * @param bottom  Bottom or top of pad 
   */
  void PlotTitle(TVirtualPad* p, Double_t yd, Bool_t bottom=true) 
  {
    // Put a title on top
    p->cd();
    fTitle.ReplaceAll("@", " ");
    Double_t s = 1/yd/1.2;
    TLatex* tit = new TLatex((bottom ? kRightMargin : p->GetLeftMargin()),
			     (bottom ? 0.01 : .99), fTitle.Data());
    tit->SetNDC();
    tit->SetTextFont(kFont);
    tit->SetTextAlign(bottom ? 11 : 13);
    tit->SetTextSize(s*0.045);
    tit->SetTextColor(kAlicePurple);
    tit->Draw();
  }

  //__________________________________________________________________
  /** 
   * Build main legend 
   * 
   * @param stack    Stack to include 
   * @param mg       (optional) Multi graph to include 
   * @param x1       Lower X coordinate in the range [0,1]
   * @param y1       Lower Y coordinate in the range [0,1]
   * @param x2       Upper X coordinate in the range [0,1]
   * @param y2 	     Upper Y coordinate in the range [0,1]
   * @param forceCol If non-zero, force this many columns
   */
  void BuildLegend(THStack* stack, TMultiGraph* mg, 
		   Double_t x1, Double_t y1, Double_t x2, Double_t y2,
		   Int_t forceCol=0)
  {
    TLegend* l = new TLegend(x1,y1,x2,y2);
    Int_t nCol = forceCol;
    if (nCol <= 0) nCol = HasCent() ? 1 : 2;
    l->SetNColumns(nCol);
    l->SetFillColor(0);
    l->SetFillStyle(0);
    l->SetBorderSize(0);
    l->SetTextFont(kFont);
    l->SetTextColor(kAliceBlue);

    // Loop over items in stack and get unique items, while ignoring
    // mirrored data and systematic error bands 
    TIter    next(stack->GetHists());
    TH1*     hist = 0;
    TObjArray unique;
    unique.SetOwner();
    Bool_t   sysErrSeen = false;
    Bool_t   mirrorSeen = false;
    while ((hist = static_cast<TH1*>(next()))) { 
      TString t(hist->GetTitle());
      TString n(hist->GetName());
      n.ToLower();
      if (t.Contains("mirrored")) { mirrorSeen = true; continue; }
      if (n.Contains("syserror")) { sysErrSeen = true; continue; }
      if (unique.FindObject(t.Data())) continue;
      // TObjString* s1 = new TObjString(hist->GetTitle());
      TParameter<float>* s1 = new TParameter<float>(t,hist->GetMarkerSize());
      s1->SetUniqueID(((hist->GetMarkerStyle() & 0xFFFF) << 16) |
		      ((hist->GetMarkerColor() & 0xFFFF) <<  0));
      unique.Add(s1);
      // l->AddEntry(hist, hist->GetTitle(), "pl");
    }
    if (mg) {
      // If we have other stuff, scan for unique names 
      TIter nexto(mg->GetListOfGraphs());
      TGraph* g = 0;
      while ((g = static_cast<TGraph*>(nexto()))) { 
	TString n(g->GetTitle());
	if (n.Contains("mirrored")) continue;
	if (unique.FindObject(n.Data())) continue;
	// TObjString* s2 = new TObjString(n);
	TParameter<float>* s2 = new TParameter<float>(n,g->GetMarkerSize());
	s2->SetUniqueID(((g->GetMarkerStyle() & 0xFFFF) << 16) |
			 ((g->GetMarkerColor() & 0xFFFF) <<  0));
	unique.Add(s2);
	// l->AddEntry(hist, hist->GetTitle(), "pl");
      }
    }

    // Add legend entries for unique items only
    TIter nextu(&unique);
    // TObject* s = 0;
    TParameter<float>* s = 0;
    Int_t i = 0;
    while ((s = static_cast<TParameter<float>*>(nextu()))) { 
      TLegendEntry* dd = l->AddEntry(Form("data%2d", i++), 
				     s->GetName(), "lp");
      Int_t style = (s->GetUniqueID() >> 16) & 0xFFFF;
      Int_t color = (s->GetUniqueID() >>  0) & 0xFFFF;
      dd->SetLineColor(kBlack);
      if (HasCent()) dd->SetMarkerColor(kBlack);
      else           dd->SetMarkerColor(color);
      dd->SetMarkerStyle(style);
      dd->SetMarkerSize(s->GetVal());
    }
    if (sysErrSeen) {
      // Add entry for systematic errors 
      TLegendEntry* d0 = l->AddEntry("d0", Form("%4.1f%% Systematic error", 
						100*fFwdSysErr), "f");
      d0->SetLineColor(kSysErrColor);
      d0->SetMarkerColor(kSysErrColor);
      d0->SetFillColor(kSysErrColor);
      d0->SetFillStyle(SYSERR_STYLE);
      d0->SetMarkerStyle(0);
      d0->SetLineWidth(0);
      i++;
    }
    if (nCol == 2 && i % 2 == 1)  {
      // To make sure the 'data' and 'mirrored' entries are on a line
      // by themselves 
      TLegendEntry* dd = l->AddEntry("dd", "   ", "");
      dd->SetTextSize(0);
      dd->SetFillStyle(0);
      dd->SetFillColor(0);
      dd->SetLineWidth(0);
      dd->SetLineColor(0);
      dd->SetMarkerSize(0);
    }
    if (mirrorSeen /* (fOptions & kMirror) */) {
      // Add entry for 'data'
      TLegendEntry* d1 = l->AddEntry("d1", "Data", "lp");
      d1->SetLineColor(kBlack);
      d1->SetMarkerColor(kBlack);
      d1->SetMarkerStyle(20);

      // Add entry for 'mirrored data'
      TLegendEntry* d2 = l->AddEntry("d2", "Mirrored data", "lp");
      d2->SetLineColor(kBlack);
      d2->SetMarkerColor(kBlack);
      d2->SetMarkerStyle(24);
    }
    
    l->Draw();
  }
  //__________________________________________________________________
  /** 
   * Build centrality legend 
   * 
   * @param x1      Lower X coordinate in the range [0,1]
   * @param y1      Lower Y coordinate in the range [0,1]
   * @param x2      Upper X coordinate in the range [0,1]
   * @param y2 	    Upper Y coordinate in the range [0,1]
   */
  void BuildCentLegend(Double_t x1, Double_t y1, Double_t x2, Double_t y2)
  {
    if (!HasCent()) return;

    if (fCentAxis->GetNbins() <= 4) y1 += .15;
    TLegend* l = new TLegend(x1,y1,x2,y2);
    l->SetNColumns(1);
    l->SetFillColor(0);
    l->SetFillStyle(0);
    l->SetBorderSize(0);
    l->SetTextFont(kFont);
    l->SetTextColor(kAliceBlue);

    Int_t n = fCentAxis->GetNbins();
    for (Int_t i = 1; i <= n; i++) { 
      Double_t low = fCentAxis->GetBinLowEdge(i);
      Double_t upp = fCentAxis->GetBinUpEdge(i);
      TLegendEntry* e = l->AddEntry(Form("dummy%02d", i),
				    Form("%3d%% - %3d%%", 
					 int(low), int(upp)), "pl");
      e->SetMarkerColor(GetCentralityColor(i));
    }
    l->Draw();
  }
  //__________________________________________________________________
  void AttachExec(TVirtualPad* p, const char* plot, UShort_t id, 
		  Bool_t isBottom) 
  {
    if (!(fOptions & kAddExec)) return;

    if (isBottom) {
      fRangeParam->fMasterAxis = FindXAxis(p, plot);
      p->AddExec("range", Form("RangeExec((dNdetaDrawer::RangeParam*)%p)", 
				fRangeParam));
    }
    else { 
      if (id == 1) {
	fRangeParam->fSlave1Axis = FindXAxis(p, plot);
	fRangeParam->fSlave1Pad  = p;
      }
      else if (id == 2) {
	fRangeParam->fSlave2Axis = FindXAxis(p, plot);
	fRangeParam->fSlave2Pad  = p;
      }
    }
  }
  //__________________________________________________________________
  /** 
   * Plot the results
   *    
   * @param max       Maximum 
   * @param yd        Bottom position of pad 
   */
  void PlotResults(Double_t max, Double_t yd, Double_t s) 
  {
    // --- Make a sub-pad for the result itself ----------------------
    TPad* p1 = new TPad("p1", "p1", 0, yd, 1.0, 1.0, 0, 0, 0);
    p1->SetTopMargin(kRightMargin);
    p1->SetBorderSize(0);
    p1->SetBorderMode(0);
    p1->SetBottomMargin(yd > 0.001 ? 0.001 : 0.1);
    p1->SetRightMargin(kRightMargin);
    if ((fOptions & kShowLeftRight) || (fOptions & kShowRatios)) p1->SetGridx();
    p1->SetTicks(1,1);
    p1->SetNumber(1);
    p1->Draw();
    p1->cd();

    // --- Figure out min/max ----------------------------------------
    // Info("PlotResults", "Plotting results with max=%f", max);
    fResults->SetMaximum((fOptions & kExtraWhite ? 1.4 : 1.15)*max);
    fResults->SetMinimum(yd > 0.00001 ? -0.02*max : 0);
    // fResults->SetMinimum(yd > 0.00001 ? -0.02*max : 0);

    // --- Fix up axis -----------------------------------------------
    Double_t yyd  = (1-yd)*(yd > .001 ? 1 : .9 / 1.2);
    FixAxis(fResults, yyd, 
	    "1/#it{N}#kern[.1]{d#it{N}_{ch}/d#it{#eta}}"
	    //"#frac{1}{#it{N}}#kern[.1]{#frac{d#it{N}_{ch}}{d#it{#eta}}}"
	    );

    // --- Fix up marker size ---------------------------------------
    TIter next(fResults->GetHists());
    TH1*  h = 0;
    while ((h = static_cast<TH1*>(next()))) 
      h->SetMarkerSize(h->GetMarkerSize()*s);
    // --- Clear pad and re-draw ------------------------------------
    p1->Clear();
    fResults->DrawClone("nostack e1");

    // --- Draw other data -------------------------------------------
    if (fShowOthers != 0) {
      TGraphAsymmErrors* o      = 0;
      TIter              nextG(fOthers->GetListOfGraphs());
      while ((o = static_cast<TGraphAsymmErrors*>(nextG()))) {
	Double_t gS = s;
	switch (o->GetMarkerStyle()) { 
	case 29: 
	case 30: gS *= 1.2; break; // Star		
	case 27: 
	case 33: gS *= 1.2; break; // Diamond
	}
	o->SetMarkerSize(o->GetMarkerSize()*gS);
	  
        o->DrawClone("same p");
      }
    }

    // --- Make a legend in the result pad ---------------------------
    Double_t x1 = p1->GetLeftMargin()+.08;
    Double_t x2 = 1-p1->GetRightMargin()-.08;
    Double_t y1 = p1->GetBottomMargin()+.01;
    Double_t y2 = .35;
    Int_t    nC = 2;
    if (HasCent()) { 
      if (fCentAxis->GetNbins() <= 4) {
	x1 = p1->GetLeftMargin()+.15;
	x2 = 1-p1->GetRightMargin()-.15;
	y2 = .2;
      }
      else {
	nC = 1;
	if (fOptions & kExtraWhite) { 
	  x1 = .40;
	  x2 = .60;
	  y1 = .70;
	  y2 = 1-p1->GetTopMargin()-0.06;
	}
	else {
	  x1 = .70;
	  x2 = 1-p1->GetRightMargin()-.01;
	  y1 = .50;
	  y2 = 1-p1->GetTopMargin()-0.16;
	}
      }
    }	
    BuildLegend(fResults, fOthers, x1, y1, x2, y2, nC);

    // --- Parameters for stuff on the right -------------------------
    Double_t yTop      = 1-p1->GetTopMargin()-.02;
    Double_t xR        = .95;
    Double_t yR        = yTop;

    // --- Put a nice label in the plot ------------------------------
    TString     eS;
    UShort_t    snn = fSNNString->GetUniqueID();
    const char* sys = fSysString->GetTitle();
    if (snn == 2750) snn = 2760;
    if (snn < 1000)           eS = Form("%3dGeV", snn);
    else if (snn % 1000 == 0) eS = Form("%dTeV", snn/1000);
    else                      eS = Form("%.2fTeV", float(snn)/1000);
    Bool_t nn = (fSysString->GetUniqueID() != 1);
    TString tS(fTrigString->GetTitle());
    if (HasCent()) { 
      tS  = "by centrality";
      UShort_t trg = fTrigString->GetUniqueID();
      switch (trg) { 
      case 0x10: tS.Append(" (V0M)"); break;
      case 0x20: tS.Append(" (V0A)"); break;
      case 0x40: tS.Append(" (ZNA)"); break;
      case 0x80: tS.Append(" (ZNC)"); break;
      }
    }
    
    TLatex* tt = new TLatex(xR, yR, Form("%s #sqrt{s%s}=%s, %s", 
					 sys, (nn ? "_{NN}" : ""),
					 eS.Data(), tS.Data()));
    tt->SetTextColor(kAliceBlue);
    tt->SetNDC();
    tt->SetTextFont(kFont);
    tt->SetTextAlign(33);
    tt->Draw();
    yR -= tt->GetTextSize() + .01;
    
    if (fSysString->GetUniqueID() == 3) { 
      // pPb - put arrow at y_CM
      UShort_t a1  = 1;
      UShort_t a2  = 208;
      UShort_t z1  = 1;
      UShort_t z2  = 82;
      Double_t yCM = .5 * TMath::Log(Float_t(z1*a2)/z2/a1);
      TArrow*  a   = new TArrow(yCM, 0, yCM, 0.05*max, 0.01, "<|");
      a->SetAngle(30);
      a->SetFillColor(kAliceBlue);
      a->SetLineColor(kAliceBlue);
      a->Draw();
    }

    // --- Put number of accepted events on the plot -----------------
    Int_t nev = 0;
    if (fTriggers) nev = fTriggers->GetBinContent(1);
    TLatex* et = new TLatex(xR, yR, Form("%d events", nev));
    et->SetTextColor(kAliceBlue);
    et->SetNDC();
    et->SetTextFont(kFont);
    et->SetTextAlign(33);
    et->Draw();
    yR -= et->GetTextSize() + .01;

    // --- Put vertex axis on the plot -------------------------------
    if (fVtxAxis) { 
      TLatex* vt = new TLatex(xR, yR, fVtxAxis->GetTitle());
      vt->SetNDC();
      vt->SetTextFont(kFont);
      vt->SetTextAlign(33);
      vt->SetTextColor(kAliceBlue);
      vt->Draw();
      yR -= vt->GetTextSize() + .01;
    }
    // results->Draw("nostack e1 same");

    // --- Put statement on corrections used on the plot -------------
    TString corrs;
    if (!fEmpirical.IsNull()) corrs.Append("Emperical");
    if (!fFinalMC.IsNull())   {
      if (!corrs.IsNull()) corrs.Append("+");
      corrs.Append("Final MC");
    }

    if (!corrs.IsNull()) {
      corrs.Append(" correction");
      if (corrs.Index("+") != kNPOS) corrs.Append("s");
      TLatex* em = new TLatex(xR, yR, corrs);
      em->SetNDC();
      em->SetTextFont(kFont);
      em->SetTextAlign(33);
      em->SetTextColor(kAliceBlue);
      em->Draw();
      yR -= em->GetTextSize() + .01;
    }

    // --- Put trigger efficiency on the plot (only pp and if != 1) --
    if (fTriggerEff > 0 && fTriggerEff < 1 && !HasCent()) { 
      TLatex* ef = new TLatex(xR, yR, Form("#varepsilon_{%s} = %5.3f", 
					 fTrigString->GetTitle(), 
					 fTriggerEff));
      ef->SetNDC();
      ef->SetTextFont(kFont);
      ef->SetTextAlign(33);
      ef->SetTextColor(kAliceBlue);
      ef->Draw();
      yR -= ef->GetTextSize() + .01;
    }

    // --- Put logo on the plot --------------------------------------
    if (fOptions & kLogo) {
      TString savPath(gROOT->GetMacroPath());
      TString fwd("$(ALICE_ROOT)/PWGLF/FORWARD/analysis2");
      gROOT->SetMacroPath(Form("%s:%s/scripts",
			       gROOT->GetMacroPath(), fwd.Data()));
      // Always recompile 
      if (!gROOT->GetClass("AliceLogo"))
	gROOT->LoadMacro("AliceLogo.C+");
      gROOT->SetMacroPath(savPath);
      
      if (gROOT->GetClass("AliceLogo")) {
	yR -= .22;
	p1->cd();
	p1->Range(0,0,1,1);
	gROOT->ProcessLine("AliceLogo* al = new AliceLogo();");
	gROOT->ProcessLine(Form("al->Draw(0,.88,%f,.2, 0, 0);", yR));
	yR -= .01;
      }
    }

    
    // --- Parameter for stuff on the left ---------------------------
    Double_t yL = yTop;
    Double_t xL = .12;

    // --- Mark as work in progress ----------------------------------
    TLatex* pt = new TLatex(xL, yL, "Work in progress");
    pt->SetNDC();
    pt->SetTextFont(62);
    // pt->SetTextSize();
    pt->SetTextColor(kAliceRed);
    pt->SetTextAlign(13);
    pt->Draw();
    yL -= pt->GetTextSize()+.01;

    TDatime now;    
    TLatex* dt = new TLatex(xL, yL, now.AsSQLString());
    dt->SetNDC();
    dt->SetTextFont(42);
    dt->SetTextSize(0.04);
    dt->SetTextColor(kAliceBlue); // kAliceRed);
    dt->SetTextAlign(13);
    dt->Draw();
    yL -= dt->GetTextSize()+.01;

    // --- Possible centrality legend --------------------------------
    BuildCentLegend(xL, yL-.4, xL+.23, yL);

    // --- Attach Zoom executor --------------------------------------
    AttachExec(p1, fResults->GetName(), 1, false);

    // --- Possibly add title ----------------------------------------
    if (yd < 0.0001) PlotTitle(p1, yyd, true);

    p1->cd();
  }
  //__________________________________________________________________
  /** 
   * Plot the ratios 
   * 
   * @param max     Maximum diviation from 1 
   * @param y1      Lower y coordinate of pad
   * @param y2      Upper y coordinate of pad
   */
  void PlotRatios(Double_t max, Double_t y1, Double_t y2) 
  {
    if ((fOptions & kShowRatios) == 0) return;

    bool isBottom = (y1 < 0.0001);
    Double_t yd = y2 - y1;

    // --- Make a sub-pad for the ratios -----------------------------
    TPad* p2 = new TPad("p2", "p2", 0, y1, 1.0, y2, 0, 0, 0);
    p2->SetTopMargin(0.001);
    p2->SetRightMargin(kRightMargin);
    p2->SetBottomMargin(isBottom ? 1/yd * 0.07 : 0.0001);
    p2->SetGridx();
    p2->SetTicks(1,1);
    p2->SetNumber(2);
    p2->Draw();
    p2->cd();

    // --- Fix up axis -----------------------------------------------
    FixAxis(fRatios, yd, "Ratios", 7);

    // --- Set up min/max --------------------------------------------
    fRatios->SetMaximum(1+TMath::Max(.22,1.05*max));
    fRatios->SetMinimum(1-TMath::Max(.32,1.05*max));

    // --- Clear pad and draw ----------------------------------------
    p2->Clear();
    fRatios->DrawClone("nostack e1");

    
    // --- Make a legend ---------------------------------------------
    BuildLegend(fRatios, 0, .15,p2->GetBottomMargin()+.01,.9,
		isBottom ? .6 : .4, 2);

    // --- Make a nice band from 0.9 to 1.1 --------------------------
    TGraphErrors* band = new TGraphErrors(2);
    band->SetPoint(0, fResults->GetXaxis()->GetXmin(), 1);
    band->SetPoint(1, fResults->GetXaxis()->GetXmax(), 1);
    band->SetPointError(0, 0, (fFwdSysErr > 0 ? fFwdSysErr : .1));
    band->SetPointError(1, 0, (fFwdSysErr > 0 ? fFwdSysErr : .1));
    band->SetFillColor(kYellow+2);
    band->SetFillStyle(3002);
    band->SetLineStyle(2);
    band->SetLineWidth(1);
    band->Draw("3 same");
    band->DrawClone("X L same");
    
    // --- Replot the ratios on top ----------------------------------
    fRatios->DrawClone("nostack e1 same");

    // --- Some more stuff -------------------------------------------
    AttachExec(p2, fRatios->GetName(), 2, isBottom);
    if (isBottom) PlotTitle(p2, yd, true);
  }
  //__________________________________________________________________
  /** 
   * Plot the asymmetries
   * 
   * @param max     Maximum diviation from 1 
   * @param y1      Lower y coordinate of pad
   * @param y2      Upper y coordinate of pad
   */
  void PlotLeftRight(Double_t max, Double_t y1, Double_t y2) 
  {
    if (!(fOptions & kShowLeftRight)) return;

    bool isBottom = (y1 < 0.0001);
    Double_t yd = y2 - y1;
    // --- Make a sub-pad for the asymmetry --------------------------
    TPad* p3 = new TPad("p3", "p3", 0, y1, 1.0, y2, 0, 0, 0);
    p3->SetTopMargin(0.001);
    p3->SetRightMargin(kRightMargin);
    p3->SetBottomMargin(isBottom ? 1/yd * 0.07 : 0.0001);
    p3->SetGridx();
    p3->SetTicks(1,1);
    p3->SetNumber(2);
    p3->Draw();
    p3->cd();

    // --- Fix up axis -----------------------------------------------
    FixAxis(fLeftRight, yd, "Right/Left", 4);

    // ---- Setup min/max --------------------------------------------
    fLeftRight->SetMaximum(1+TMath::Max(.12,1.05*max));
    fLeftRight->SetMinimum(1-TMath::Max(.15,1.05*max));

    // --- Clear pad and redraw --------------------------------------
    p3->Clear();
    fLeftRight->DrawClone("nostack e1");

    
    // --- Make a legend ---------------------------------------------
    Double_t xx1 = (HasCent() ? .7                           : .15); 
    Double_t xx2 = (HasCent() ? 1-p3->GetRightMargin()-.01   : .90);
    Double_t yy1 = p3->GetBottomMargin()+.01;
    Double_t yy2 = (HasCent() ? 1-p3->GetTopMargin()-.01-.15 : .5);
    BuildLegend(fLeftRight, 0, xx1, yy1, xx2, yy2);

    // --- Make a nice band from 0.9 to 1.1 --------------------------
    TGraphErrors* band = new TGraphErrors(2);
    band->SetPoint(0, fResults->GetXaxis()->GetXmin(), 1);
    band->SetPoint(1, fResults->GetXaxis()->GetXmax(), 1);
    band->SetPointError(0, 0, (fFwdSysErr > 0 ? fFwdSysErr : .05));
    band->SetPointError(1, 0, (fFwdSysErr > 0 ? fFwdSysErr : .05));
    band->SetFillColor(kYellow+2);
    band->SetFillStyle(3002);
    band->SetLineStyle(2);
    band->SetLineWidth(1);
    band->Draw("3 same");
    band->DrawClone("X L same");

    // --- Re-draw over ----------------------------------------------
    fLeftRight->DrawClone("nostack e1 same");

    // --- Misc stuff ------------------------------------------------
    AttachExec(p3, fLeftRight->GetName(), 2, isBottom);
    if (isBottom) PlotTitle(p3, yd, true);
  }
  /** @} */
  //==================================================================
  /** 
   * @{ 
   * @name Data utility functions 
   */
  //__________________________________________________________________
  /** 
   * Get the color for a centrality bin
   * 
   * @param bin Centrality bin 
   * 
   * @return Color 
   */
  Int_t GetCentralityColor(Int_t bin) const
  {
    if (fCentAxis->GetNbins() < 6) { 
      switch (bin) { 
      case 1: return kRed+2;
      case 2: return kGreen+2;
      case 3: return kBlue+1;
      case 4: return kCyan+1;
      case 5: return kMagenta+1;
      case 6: return kYellow+2;
      }
    }
    UShort_t centLow  = fCentAxis->GetBinLowEdge(bin);
    UShort_t centHigh = fCentAxis->GetBinUpEdge(bin);
    Float_t  fc       = (centLow+double(centHigh-centLow)/2) / 100;
    Int_t    nCol     = gStyle->GetNumberOfColors();
    Int_t    icol     = TMath::Min(nCol-1,int(fc * nCol + .5));
    Int_t    col      = gStyle->GetColorPalette(icol);
    //Info("GetCentralityColor","%3d: %3d-%3d -> %3d",bin,centLow,centHigh,col);
    return col;
  }
  //__________________________________________________________________
  /** 
   * Set attributed on a histogram 
   * 
   * @param h     Histogram
   * @param color Color 
   */
  void SetAttributes(TH1* h, Int_t color)
  {
    if (!h) return;
    if (color < 0) return;
    h->SetLineColor(color);
    h->SetMarkerColor(color);
    // h->SetFillColor(color);
  }
  //__________________________________________________________________
  /** 
   * Set attributed on a graph 
   * 
   * @param g     Graph
   * @param color Color 
   */
  void SetAttributes(TGraph* g, Int_t color)
  {
    if (!g) return;
    if (color < 0) return;
    // g->SetLineColor(color);
    g->SetMarkerColor(color);
    // g->SetFillColor(color);
  }
  //__________________________________________________________________
  /** 
   * Modify the title 
   * 
   */
  void ModifyTitle(TNamed* h, const char* centTxt)
  {
    if (!h) return;

    TString title(h->GetTitle());
    title.ReplaceAll("ALICE ","");
    if (title.Contains("Central")) 
      title.ReplaceAll("CentraldNdeta", "SPD clusters");
    if (title.Contains("Forward"))
      title.ReplaceAll("ForwarddNdeta", "FMD");
    h->SetTitle(title);

    if (centTxt && centTxt[0] != '\0') {
      TString name(h->GetName());
      name.Append(Form("_%s", centTxt));
      h->SetName(name);
    }
    
    return;
    // if (!centTxt || !h) return;
    // h->SetTitle(Form("%s, %s", h->GetTitle(), centTxt));
  }
  /** 
   * Get a result from the passed list
   * 
   * @param list List to search 
   * @param name Object name to search for 
   * 
   * @return Histogram
   */
  TH1* FetchHistogram(const TList* list, const char* name) const 
  {
    if (!list) return 0;
    
    TH1* ret = static_cast<TH1*>(list->FindObject(name));
#if 0
    if (!ret) {
      // all->ls();
      Warning("GetResult", "Histogram %s not found", name);
    }
#endif

    return ret;
  }
  //__________________________________________________________________
  /** 
   * Add a histogram to the stack after possibly rebinning it  
   * 
   * @param stack   Stack to add to 
   * @param hist    histogram
   * @param option  Draw options 
   * 
   * @return Maximum of histogram 
   */
  Double_t AddHistogram(THStack* stack, TH1* hist, Option_t* option="") const 
  {
    // Check if we have input 
    if (!hist) return 0;

    // Rebin if needed 
    Rebin(hist);

    stack->Add(hist, option);
    return hist->GetMaximum();
  }
  //__________________________________________________________________
  /** 
   * Add a histogram to the stack after possibly rebinning it  
   * 
   * @param stack   Stack to add to 
   * @param hist    histogram
   * @param option  Draw options 
   * @param sym     On return, the data symmetriced (added to stack)
   * 
   * @return Maximum of histogram 
   */
  Double_t AddHistogram(THStack* stack, TH1* hist, TH1*& sym,
			Option_t* option="") const 
  {
    // Check if we have input 
    if (!hist) return 0;

    // Rebin if needed 
    Rebin(hist);
    stack->Add(hist, option);

    // Now symmetrice the histogram 
    if ((fOptions & kMirror)) {
      sym = Symmetrice(hist);
      stack->Add(sym, option);
    }

    return hist->GetMaximum();
  }

  //__________________________________________________________________
  /** 
   * Rebin a histogram 
   * 
   * @param h     Histogram to rebin
   */
  virtual void Rebin(TH1* h) const
  { 
    if (fRebin <= 1) return;

    Int_t nBins = h->GetNbinsX();
    if(nBins % fRebin != 0) {
      Warning("Rebin", "Rebin factor %d is not a devisor of current number "
	      "of bins %d in the histogram %s", fRebin, nBins, h->GetName());
      return;
    }
    
    // Make a copy 
    TH1* tmp = static_cast<TH1*>(h->Clone("tmp"));
    tmp->Rebin(fRebin);
    tmp->SetDirectory(0);
    tmp->Reset();
    // The new number of bins 
    Int_t nBinsNew = nBins / fRebin;
    for(Int_t i = 1;i<= nBinsNew; i++) {
      Double_t content = 0;
      Double_t sumw    = 0;
      Double_t wsum    = 0;
      Int_t    nbins   = 0;
      for(Int_t j = 1; j<=fRebin;j++) {
	Int_t    bin = (i-1)*fRebin + j;
	Double_t c   =  h->GetBinContent(bin);

	if (c <= 0) continue;

	if ((fOptions & kCutEdges)) {
	  if (h->GetBinContent(bin+1)<=0 || 
	      h->GetBinContent(bin-1)<=0) {
	    Warning("Rebin", "removing bin %d=%f of %s (%d=%f,%d=%f)", 
		    bin, c, h->GetName(), 
		    bin+1, h->GetBinContent(bin+1), 
		    bin-1, h->GetBinContent(bin-1));
	    continue;
	  }	
	}
	Double_t e =  h->GetBinError(bin);
	Double_t w =  1 / (e*e); // 1/c/c
	content    += c;
	sumw       += w;
	wsum       += w * c;
	nbins++;
      }
      
      if(content > 0 && nbins > 1 ) {
	tmp->SetBinContent(i, wsum / sumw);
	tmp->SetBinError(i,1./TMath::Sqrt(sumw));
      }
    }

    // Finally, rebin the histogram, and set new content
    h->Rebin(fRebin);
    h->Reset();
    for(Int_t i = 1; i<= nBinsNew; i++) {
      h->SetBinContent(i,tmp->GetBinContent(i));
      h->SetBinError(i,  tmp->GetBinError(i));
    }
    
    delete tmp;
  }
  //__________________________________________________________________
  /** 
   * Make an extension of @a h to make it symmetric about 0 
   * 
   * @param h Histogram to symmertrice 
   * 
   * @return Symmetric extension of @a h 
   */
  TH1* Symmetrice(const TH1* h) const
  {
    Int_t nBins = h->GetNbinsX();
    TH1* s = static_cast<TH1*>(h->Clone(Form("%s_mirror", h->GetName())));
    s->SetTitle(Form("%s (mirrored)", h->GetTitle()));
    s->Reset();
    s->SetBins(nBins, -h->GetXaxis()->GetXmax(), -h->GetXaxis()->GetXmin());
    s->SetMarkerColor(h->GetMarkerColor());
    s->SetMarkerSize(h->GetMarkerSize());
    s->SetMarkerStyle(h->GetMarkerStyle()+4);
    s->SetFillColor(h->GetFillColor());
    s->SetFillStyle(h->GetFillStyle());
    s->SetDirectory(0);

    // Find the first and last bin with data 
    Int_t first = nBins+1;
    Int_t last  = 0;
    for (Int_t i = 1; i <= nBins; i++) { 
      if (h->GetBinContent(i) <= 0) continue; 
      first = TMath::Min(first, i);
      last  = TMath::Max(last,  i);
    }
    
    Double_t xfirst = h->GetBinCenter(first-1);
    Int_t    f1     = h->GetXaxis()->FindBin(-xfirst);
    Int_t    l2     = s->GetXaxis()->FindBin(xfirst);
    for (Int_t i = f1, j=l2; i <= last; i++,j--) { 
      s->SetBinContent(j, h->GetBinContent(i));
      s->SetBinError(j, h->GetBinError(i));
    }
    // Fill in overlap bin 
    s->SetBinContent(l2+1, h->GetBinContent(first));
    s->SetBinError(l2+1, h->GetBinError(first));
    return s;
  }
  //__________________________________________________________________
  /** 
   * Calculate the left-right asymmetry of input histogram 
   * 
   * @param h   Input histogram
   * @param max On return, the maximum distance from 1 of the histogram
   * 
   * @return Asymmetry 
   */
  TH1* Asymmetry(TH1* h, Double_t& max)
  {
    if (!h) return 0;

    TH1* ret = static_cast<TH1*>(h->Clone(Form("%s_leftright", h->GetName())));
    // Int_t    oBins = h->GetNbinsX();
    // Double_t high  = h->GetXaxis()->GetXmax();
    // Double_t low   = h->GetXaxis()->GetXmin();
    // Double_t dBin  = (high - low) / oBins;
    // Int_t    tBins = Int_t(2*high/dBin+.5);
    // ret->SetBins(tBins, -high, high);
    ret->SetDirectory(0);
    ret->Reset();
    ret->SetTitle(Form("%s (+/-)", h->GetTitle()));
    ret->SetYTitle("Right/Left");
    Int_t nBins = h->GetNbinsX();
    for (Int_t i = 1; i <= nBins; i++) { 
      Double_t x = h->GetBinCenter(i);
      if (x > 0) break;
      
      Double_t c1 = h->GetBinContent(i);
      Double_t e1 = h->GetBinError(i);
      if (c1 <= 0) continue; 
      
      Int_t    j  = h->FindBin(-x);
      if (j <= 0 || j > nBins) continue;

      Double_t c2 = h->GetBinContent(j);
      Double_t e2 = h->GetBinError(j);

      Double_t c12 = c1*c1;
      Double_t e   = TMath::Sqrt((e2*e2*c1*c1+e1*e1*c2*c2)/(c12*c12));
      
      Int_t    k   = ret->FindBin(x);
      ret->SetBinContent(k, c2/c1);
      ret->SetBinError(k, e);
    }
    max = TMath::Max(max, RatioMax(ret));

    return ret;
  }
  //__________________________________________________________________
  /** 
   * Transform a graph into a histogram 
   * 
   * @param g Graph
   * 
   * @return Histogram
   */
  TH1* Graph2Hist(const TGraphAsymmErrors* g) const
  {
    Int_t    nBins = g->GetN();
    TArrayF  bins(nBins+1);
    Double_t dx = 0;
    for (Int_t i = 0; i < nBins; i++) { 
      Double_t x   = g->GetX()[i];
      Double_t exl = g->GetEXlow()[i];
      Double_t exh = g->GetEXhigh()[i];
      bins.fArray[i]   = x-exl;
      bins.fArray[i+1] = x+exh;
      Double_t dxi = exh+exl;
      if (i == 0) dx  = dxi;
      else if (dxi != dx) dx = 0;
    }
    TString name(g->GetName());
    TString title(g->GetTitle());
    TH1D* h = 0;
    if (dx != 0) {
      h = new TH1D(name.Data(), title.Data(), nBins, bins[0], bins[nBins]);
    }
    else {
      h = new TH1D(name.Data(), title.Data(), nBins, bins.fArray);
    }
    h->SetMarkerStyle(g->GetMarkerStyle());
    h->SetMarkerColor(g->GetMarkerColor());
    h->SetMarkerSize(g->GetMarkerSize());
    
    return h;
  }
  /* @} */
  //==================================================================
  /** 
   * @{ 
   * @name Ratio utility functions 
   */
  /** 
   * Get the maximum diviation from 1 in the passed ratio
   * 
   * @param h Ratio histogram
   * 
   * @return Max diviation from 1 
   */
  Double_t RatioMax(TH1* h) const
  {
    Int_t    nBins = h->GetNbinsX();
    Double_t ret   = 0;
    for (Int_t i = 1; i <= nBins; i++) { 
      Double_t c = h->GetBinContent(i);
      if (c == 0) continue;
      Double_t e = h->GetBinError(i);
      Double_t d = TMath::Abs(1-c-e);
      ret        = TMath::Max(d, ret);
    }
    return ret;
  }
  //__________________________________________________________________
  /** 
   * Make the ratio of h1 to h2 
   * 
   * @param o1  First object (numerator) 
   * @param o2  Second object (denominator)
   * @param max Maximum diviation from 1 
   * 
   * @return o1 / o2
   */
  TH1* Ratio(const TObject* o1, const TObject* o2, Double_t& max) const
  {
    if (!o1 || !o2) return 0;

    bool mirror = false;
    TString n1(o1->GetName());
    if (n1.Contains("mirror")) mirror = true;

    TH1*        r  = 0;
    const TAttMarker* m1 = 0;
    const TAttMarker* m2 = 0;
    const TH1* h1 = dynamic_cast<const TH1*>(o1); 
    if (h1) { 
      m1 = h1;
      const TH1* h2 = dynamic_cast<const TH1*>(o2); 
      if (h2) { 
	m2 = h2;
	r = RatioHH(h1,h2);
      }
      else {
	const TGraph* g2 = dynamic_cast<const TGraph*>(o2);
	if (g2) { 
	  m2 = g2;
	  r = RatioHG(h1,g2);      
	}
      }
    }
    else {
      const TGraphAsymmErrors* g1 = dynamic_cast<const TGraphAsymmErrors*>(o1);
      if (g1) { 
	m1 = g1;
	const TGraphAsymmErrors* g2 = 
	  dynamic_cast<const TGraphAsymmErrors*>(o2);
	if (g2) {
	  m2 = g2;
	  r = RatioGG(g1, g2);
	}
      }
    }
    if (!r) {
      // Warning("Ratio", "Don't know how to divide a %s (%s) with a %s (%s)", 
      //         o1->ClassName(),o1->GetName(),o2->ClassName(),o2->GetName());
      return 0;
    }
    // Check that the histogram isn't empty
    if (r->GetEntries() <= 0) { 
      delete r; 
      r = 0; 
    }
    if (r) {
      UShort_t m2bits = MarkerUtil::GetMarkerBits(m2->GetMarkerStyle());
      if (mirror) m2bits |= MarkerUtil::kHollow;
      else        m2bits &= ~MarkerUtil::kHollow;
      r->SetMarkerStyle(MarkerUtil::GetMarkerStyle(m2bits));
      r->SetMarkerColor(m1->GetMarkerColor());
      if (TString(o2->GetName()).Contains("truth", TString::kIgnoreCase)) 
	r->SetMarkerStyle(m1->GetMarkerStyle());
      r->SetMarkerSize(0.9*m1->GetMarkerSize());
      r->SetName(Form("%s_over_%s", o1->GetName(), o2->GetName()));
      r->SetTitle(Form("%s / %s", o1->GetTitle(), o2->GetTitle()));
      r->SetDirectory(0);
      max = TMath::Max(RatioMax(r), max);
    }

    return r;
  }
  //__________________________________________________________________
  /** 
   * Compute the ratio of @a h to @a g.  @a g is evaluated at the bin
   * centers of @a h 
   * 
   * @param h  Numerator 
   * @param g  Divisor 
   * 
   * @return h/g 
   */
  TH1* RatioHG(const TH1* h, const TGraph* g) const 
  {
    if (!h || !g) return 0;

    TH1* ret = static_cast<TH1*>(h->Clone("tmp"));
    ret->Reset();
    Int_t    n     = g->GetN();
    Double_t xlow  = g->GetX()[0];
    Double_t xhigh = g->GetX()[n-1];
    if (g->IsA()->InheritsFrom(TGraphErrors::Class())) { 
      const TGraphErrors* ge = static_cast<const TGraphErrors*>(g);
      xlow  -= ge->GetErrorXlow(0);
      xhigh += ge->GetErrorXhigh(n-1);
    }
    if (g->IsA()->InheritsFrom(TGraphAsymmErrors::Class())) { 
      const TGraphAsymmErrors* ge = static_cast<const TGraphAsymmErrors*>(g);
      xlow  -= ge->GetErrorXlow(0);
      xhigh += ge->GetErrorXhigh(n-1);
    }
    if (xlow > xhigh) { Double_t t = xhigh; xhigh = xlow; xlow = t; }

    for (Int_t i = 1; i <= h->GetNbinsX(); i++) { 
      Double_t c = h->GetBinContent(i);
      if (c <= 0) continue;

      Double_t x = h->GetBinCenter(i);
      if (x < xlow || x > xhigh) continue; 

      Double_t f = g->Eval(x);
      if (f <= 0) continue; 

      ret->SetBinContent(i, c / f);
      ret->SetBinError(i, h->GetBinError(i) / f);
    }
    return ret;
  }
  //__________________________________________________________________
  /** 
   * Make the ratio of h1 to h2 
   * 
   * @param h1 First histogram (numerator) 
   * @param h2 Second histogram (denominator)
   * 
   * @return h1 / h2
   */
  TH1* RatioHH(const TH1* h1, const TH1* h2) const
  {
    if (!h1 || !h2) return 0;
    Bool_t bad = false;
    if (h1->GetNbinsX() != h2->GetNbinsX()) {
      Error("RatioHH", "They have differnet number of bins");
      bad = true;
    }
    for (Int_t i = 1; i <= h1->GetNbinsX(); i++) {
      if (h1->GetXaxis()->GetBinLowEdge(i) != 
	  h2->GetXaxis()->GetBinLowEdge(i)) {
	// Error("RatioHH", "They have incompatible variable bins");
	bad = true;
	break;
      }
    }
    if (bad) return 0;
    
    TH1* t1 = static_cast<TH1*>(h1->Clone("tmp"));
    // Printf("Dividing %s with %s", h1->GetName(), h2->GetName());
    t1->Divide(h2);
    return t1;
  }
  //__________________________________________________________________
  /** 
   * Calculate the ratio of two graphs - g1 / g2
   * 
   * @param g1 Numerator 
   * @param g2 Denominator
   * 
   * @return g1 / g2 in a histogram 
   */
  TH1* RatioGG(const TGraphAsymmErrors* g1, 
	       const TGraphAsymmErrors* g2) const
  {
    Int_t    nBins = g1->GetN();
    TArrayF  bins(nBins+1);
    Double_t dx   = 0;
    for (Int_t i = 0; i < nBins; i++) {
      Double_t x   = g1->GetX()[i];
      Double_t exl = g1->GetEXlow()[i];
      Double_t exh = g1->GetEXhigh()[i];
      bins.fArray[i]   = x-exl;
      bins.fArray[i+1] = x+exh;
      Double_t dxi = exh+exl;
      if (i == 0) dx  = dxi;
      else if (dxi != dx) dx = 0;
    }
    TH1* h = 0;
    if (dx != 0) {
      h = new TH1F("tmp", "tmp", nBins, bins[0], bins[nBins]);
    }
    else {
      h = new TH1F("tmp", "tmp", nBins, bins.fArray);
    }

    Double_t low  = g2->GetX()[0];
    Double_t high = g2->GetX()[g2->GetN()-1];
    if (low > high) { Double_t t = low; low = high; high = t; }
    for (Int_t i = 0; i < nBins; i++) { 
      Double_t x  = g1->GetX()[i];
      if (x < low-dx || x > high+dx) continue;
      Double_t c1 = g1->GetY()[i];
      Double_t e1 = g1->GetErrorY(i);
      Double_t c2 = g2->Eval(x);
      
      h->SetBinContent(i+1, c1 / c2);
      h->SetBinError(i+1, e1 / c2);
    }
    return h;
  }  
  /* @} */
  //==================================================================
  /** 
   * @{ 
   * @name Graphics utility functions 
   */
  /** 
   * Find an X axis in a pad 
   * 
   * @param p     Pad
   * @param name  Histogram to find axis for 
   * 
   * @return Found axis or null
   */
  TAxis* FindXAxis(TVirtualPad* p, const char* name)
  {
    TObject* o = p->GetListOfPrimitives()->FindObject(name);
    if (!o) { 
      Warning("FindXAxis", "%s not found in pad", name);
      return 0;
    }
    THStack* stack = dynamic_cast<THStack*>(o);
    if (!stack) { 
      Warning("FindXAxis", "%s is not a THStack", name);
      return 0;
    }
    if (!stack->GetHistogram()) { 
      Warning("FindXAxis", "%s has no histogram", name);
      return 0;
    }
    TAxis* ret = stack->GetHistogram()->GetXaxis();
    return ret;
  }

  //__________________________________________________________________
  /**
   * Fix the apperance of the axis in a stack
   *
   * @param stack  stack of histogram
   * @param yd     How the canvas is cut
   * @param ytitle Y axis title
   * @param ynDiv  Divisions on Y axis
   * @param force  Whether to draw the stack first or not
   */
  void FixAxis(THStack* stack, Double_t yd, const char* ytitle,
               Int_t ynDiv=210, Bool_t force=true)
  {
    if (!stack) { 
      Warning("FixAxis", "No stack passed for %s!", ytitle);
      return;
    }
    Bool_t supLabel = (fResults == stack && ((fOptions & kNoLabels)));
    if (force) stack->Draw("nostack e1");

    TH1* h = stack->GetHistogram();
    if (!h) { 
      Warning("FixAxis", "Stack %s has no histogram", stack->GetName());
      return;
    }
    Double_t s = 1/yd/1.2;
    // Info("FixAxis", "for %s, s=1/%f=%f", stack->GetName(), yd, s);

    h->SetXTitle("#it{#eta}");
    h->SetYTitle(ytitle);
    TAxis* xa = h->GetXaxis();
    TAxis* ya = h->GetYaxis();

    // Int_t   npixels = 20
    // Float_t dy = gPad->AbsPixeltoY(0) - gPad->AbsPixeltoY(npixels);
    // Float_t ts = dy/(gPad->GetY2() - gPad->GetY1());

    if (xa) {
      // xa->SetTitle(h->GetXTitle());
      // xa->SetTicks("+-");
      xa->SetTitleSize(s*xa->GetTitleSize());
      xa->SetLabelSize(s*xa->GetLabelSize());
      xa->SetTickLength(s*xa->GetTickLength());
      // xa->SetTitleOffset(xa->GetTitleOffset()/s);

      if (stack != fResults) {
	TAxis* rxa = fResults->GetXaxis();
	xa->Set(rxa->GetNbins(), rxa->GetXmin(), rxa->GetXmax());
      }
    }
    if (ya) {
      // ya->SetTitle(h->GetYTitle());
      ya->SetDecimals();
      // ya->SetTicks("+-");
      ya->SetNdivisions(ynDiv);
      ya->SetTitleSize(s*ya->GetTitleSize());
      ya->SetTitleOffset(/*1.15*/1.4*ya->GetTitleOffset()/s);
      ya->SetLabelSize(supLabel ? 0 : s*ya->GetLabelSize());
    }
  }
  //__________________________________________________________________
  /** 
   * Merge two histograms into one 
   * 
   * @param cen    Central part
   * @param fwd    Forward part
   * @param xlow   On return, lower eta bound
   * @param xhigh  On return, upper eta bound
   * 
   * @return Newly allocated histogram or null
   */
  TH1* 
  Merge(const TH1* cen, const TH1* fwd, Double_t& xlow, Double_t& xhigh)
  {
    TH1* tmp = static_cast<TH1*>(fwd->Clone("tmp"));
    TString name(fwd->GetName());
    name.ReplaceAll("Forward", "Merged");
    tmp->SetName(name);

    // tmp->SetMarkerStyle(28);
    // tmp->SetMarkerColor(kBlack);
    tmp->SetDirectory(0);
    if (!cen) return tmp;

    xlow  = 100;
    xhigh = -100;
    for (Int_t i = 1; i <= tmp->GetNbinsX(); i++) {
      Double_t cc = cen->GetBinContent(i);
      Double_t cf = fwd->GetBinContent(i);
      Double_t ec = cen->GetBinError(i);
      Double_t ef = fwd->GetBinError(i);
      Double_t nc = cf;
      Double_t ne = ef;
      if (cc < 0.001 && cf < 0.01) continue;
      xlow  = TMath::Min(tmp->GetXaxis()->GetBinLowEdge(i),xlow);
      xhigh = TMath::Max(tmp->GetXaxis()->GetBinUpEdge(i),xhigh);
      if (cc > 0.001) {
	nc = cc;
	ne = ec;
	if (cf > 0.001) {
	  nc  = (cf + cc) / 2;
	  ne  = TMath::Sqrt(ec*ec + ef*ef);
	}
      }
      tmp->SetBinContent(i, nc);
      tmp->SetBinError(i, ne);
    }
    return tmp;
  }
  //____________________________________________________________________
  /** 
   * Fit  @f$g(x;A_1,A_2,\sigma_1,\sigma_2)@f$ to histogram data 
   * 
   * @param tmp    Histogram
   * @param xlow   Lower x bound
   * @param xhigh  Upper x bound 
   *
   * @return Fitted function 
   */
  TF1* 
  FitMerged(TH1* tmp, Double_t xlow, Double_t xhigh)
  {
    TF1* tmpf  = new TF1("tmpf", "gaus", xlow, xhigh);
    tmp->Fit(tmpf, "NQ", "");
    tmp->SetDirectory(0);

    TF1* fit = new TF1("f", myFunc, xlow, xhigh, 4);
    fit->SetParNames("a_{1}", "a_{2}", "#sigma_{1}", "#sigma_{2}");
    fit->SetParameters(tmpf->GetParameter(0), 
		       .2, 
		       tmpf->GetParameter(2), 
		       tmpf->GetParameter(2)/4);
    fit->SetParLimits(3, 0, 100);
    fit->SetParLimits(4, 0, 100);
    const char* fitOpts = (fOptions & kVerbose ? "0W" : "Q0W");
    tmp->Fit(fit,fitOpts,"");

    delete tmpf;
    return fit;
  }
  //____________________________________________________________________
  /** 
   * Make band of systematic errors 
   * 
   * @param tmp Histogram
   * @param cen Central 
   * @param fwd Forward 
   * @param fit Fit 
   */
  void
  MakeSysError(TH1* tmp, TH1* cen, TH1* fwd, TF1* fit)
  {
    for (Int_t i = 1; i <= tmp->GetNbinsX(); i++) {
      Double_t tc = tmp->GetBinContent(i);
      if (tc < 0.01) continue;
      Double_t fc = fwd->GetBinContent(i);
      Double_t cc = cen ? cen->GetBinContent(i) : 0;
      Double_t sysErr = fFwdSysErr;
      if (cc > .01 && fc > 0.01) 
	sysErr = (fFwdSysErr+fCenSysErr) / 2;
      else if (cc > .01) 
	sysErr = fCenSysErr;
      Double_t x = tmp->GetXaxis()->GetBinCenter(i);
      Double_t y = fit->Eval(x);
      tmp->SetBinContent(i, y);
      tmp->SetBinError(i,sysErr*y);
    }
    TString name(tmp->GetName());
    name.ReplaceAll("Merged", "SysError");
    tmp->SetName(name);
    tmp->SetMarkerColor(kSysErrColor);
    tmp->SetLineColor(kSysErrColor);
    tmp->SetFillColor(kSysErrColor);
    tmp->SetFillStyle(SYSERR_STYLE);
    tmp->SetMarkerStyle(0);
    tmp->SetLineWidth(0);
  }
  void CorrectForward(TH1* h) const
  {
    if (!(fOptions & kRemoveOuters)) return;
    
    for (Int_t i = 1; i <= h->GetNbinsX(); i++) { 
      Double_t eta = h->GetBinCenter(i);
      if (TMath::Abs(eta) < 2.3) { 
	h->SetBinContent(i, 0);
	h->SetBinError(i, 0);
      }
    }
  }
  void CorrectCentral(TH1* h) const 
  {
    if (!h) return;
    if (fClusterScale.IsNull()) return;
    TString t(h->GetTitle());
    Info("CorrectCentral", "Replacing Central with Tracklets in %s", t.Data());
    t.ReplaceAll("Central", "Tracklets");
    h->SetTitle(t);

    TF1* cf = new TF1("clusterScale", fClusterScale);
    for (Int_t i = 1; i <= h->GetNbinsX(); i++) { 
      Double_t eta = h->GetBinCenter(i);
      Double_t f   = cf->Eval(eta);
      Double_t c   = h->GetBinContent(i);
      if (f < .1) f = 1;
      h->SetBinContent(i, c / f);
    }
    delete cf;
  }
  //____________________________________________________________________
  void Export(const char* basename)
  {
    TString bname(basename);
    bname.ReplaceAll(" ", "_");
    bname.ReplaceAll("-", "_");
    TString fname(Form("%s.C", bname.Data()));

    std::ofstream outf(fname.Data());
    if (!outf) { 
      Error("Export", "Failed to open output file %s", fname.Data());
      return;
    }
    Info("Export", "Exporting data to %s", fname.Data());
    outf << "// Create by dNdetaDrawer\n"
	 << "void " << bname << "(THStack* stack, TLegend* l, Int_t m)\n"
	 << "{"
	 << "   Int_t ma[] = { 24, 25, 26, 32,\n"
	 << "                  20, 21, 22, 33,\n"
	 << "                  34, 30, 29, 0, \n"
	 << "                  23, 27 };\n"
	 << "   Int_t mm = ((m < 20 || m > 34) ? 0 : ma[m-20]);\n\n";
    TList* hists = fResults->GetHists();
    TIter  next(hists);
    TH1*   hist = 0;
    while ((hist = static_cast<TH1*>(next()))) { 
      TString hname = hist->GetName();
      hname.Append(Form("_%04x", (gRandom->Integer(0xffff) & 0xffff)));
      hist->SetName(hname);
      hist->GetListOfFunctions()->Clear();
      hist->SavePrimitive(outf, "nodraw");
      bool mirror = hname.Contains("mirror");
      bool syserr = hname.Contains("SysError");
      if (!syserr) 
	outf << "   " << hname << "->SetMarkerStyle(" 
	     << (mirror ? "mm" : "m") << ");\n";
      else 
	outf << "   " << hname << "->SetMarkerStyle(1);\n";
      outf << "   stack->Add(" << hname 
	   << (syserr ? ",\"e5\"" : "") << ");\n\n";
    }
    UShort_t    snn = fSNNString->GetUniqueID();
    // const char* sys = fSysString->GetTitle();
    TString eS;
    if      (snn == 2750)     snn = 2760;
    if      (snn < 1000)      eS = Form("%3dGeV", snn);
    else if (snn % 1000 == 0) eS = Form("%dTeV", snn/1000);
    else                      eS = Form("%4.2fTeV", float(snn)/1000);
    outf << "  if (l) {\n"
	 << "    TLegendEntry* e = l->AddEntry(\"\",\"" << eS << "\",\"pl\");\n"
	 << "    e->SetMarkerStyle(m);\n"
	 << "    e->SetMarkerColor(kBlack);\n"
	 << "  }\n"
	 << "}\n" << std::endl;
  }
  /* @} */ 
  /** 
   * Check if we have centrality dependent information, and we're not
   * forcing to use minimum bias
   * 
   * 
   * @return True if we should do centrality dependent ploting 
   */
  Bool_t HasCent() const 
  { 
    return (!(fOptions & kForceMB) && 
	    fCentAxis && 
	    (fCentAxis->GetNbins() > 1 ||
	     (fCentAxis->GetNbins() == 1 && 
	      fCentAxis->GetXmin() <= fCentAxis->GetXmax()))); 
  }



  //__________________________________________________________________
  /** 
   * @{ 
   * @name Options 
   */
  UInt_t       fOptions;      // Options 
  UInt_t       fFormats;      // Output formats
  UShort_t     fShowOthers;   // Show other data
  /* @} */
  /** 
   * @{ 
   * @name Settings 
   */
  UShort_t     fRebin;        // Rebinning factor 
  Double_t     fFwdSysErr;    // Systematic error in forward range
  Double_t     fCenSysErr;    // Systematic error in central range 
  TString      fTitle;        // Title on plot
  TString      fBase;         // Base name of output 
  TString      fClusterScale; // Scaling of clusters to tracklets      
  TString      fFinalMC;      // Final MC correction file name
  TString      fEmpirical;    // Empirical correction file name
  /* @} */
  /** 
   * @{ 
   * @name Read (or set) information 
   */
  TNamed*      fTrigString;   // Trigger string (read, or set)
  TNamed*      fNormString;   // Normalisation string (read, or set)
  TNamed*      fSNNString;    // Energy string (read, or set)
  TNamed*      fSysString;    // Collision system string (read or set)
  TAxis*       fVtxAxis;      // Vertex cuts (read or set)
  TAxis*       fCentAxis;     // Centrality axis
  TObject*     fCentMeth;     // Centrality method 
  Float_t      fTriggerEff;   // Trigger efficiency 
  Bool_t       fExtTriggerEff;// True if read externally 
  UShort_t     fCentMin;      // Least centrality to plot
  UShort_t     fCentMax;      // Largest centrality to plot
  /* @} */
  /** 
   * @{ 
   * @name Resulting plots 
   */
  THStack*     fResults;      // Stack of results 
  THStack*     fRatios;       // Stack of ratios 
  THStack*     fLeftRight;    // Left-right asymmetry
  TMultiGraph* fOthers;       // Older data 
  TH1*         fTriggers;     // Number of triggers
  TH1*         fTruth;        // Pointer to truth 
  /* @} */
  RangeParam*  fRangeParam;   // Parameter object for range zoom 
  TObject*     fEmpCorr;      // Empirical correction 

  static const Float_t kRightMargin;
  static const Int_t   kFont;
  static const Int_t   kAliceBlue;
  static const Int_t   kAliceRed;
  static const Int_t   kAlicePurple;
  static const Int_t   kAliceYellow;
  static const Int_t   kSysErrColor;
};

const Float_t dNdetaDrawer::kRightMargin = 0.01;
const Int_t   dNdetaDrawer::kFont        = 42; // 132 for serif
const Int_t   dNdetaDrawer::kAliceBlue   = TColor::GetColor(40,   58, 68);
const Int_t   dNdetaDrawer::kAliceRed    = TColor::GetColor(226,   0, 26);
const Int_t   dNdetaDrawer::kAlicePurple = TColor::GetColor(202,  71, 67);
const Int_t   dNdetaDrawer::kAliceYellow = TColor::GetColor(238, 125, 17);
const Int_t   dNdetaDrawer::kSysErrColor = SYSERR_COLOR;


//____________________________________________________________________
/** 
 * Function to calculate 
 * @f[
 *  g(x;A_1,A_2,\sigma_1,\sigma_2) = 
 *       A_1\left(\frac{1}{2\pi\sigma_1}e^{(x/\sigma_1)^2} - 
 *           A_2\frac{1}{2\pi\sigma_2}e^{(x/\sigma_2)^2}\right)
 * @f]
 * 
 * @param xp Pointer to x array
 * @param pp Pointer to parameter array 
 * 
 * @return @f$g(x;A_1,A_2,\sigma_1,\sigma_2)@f$
 */
Double_t myFunc(Double_t* xp, Double_t* pp)
{
  Double_t x  = xp[0];
  Double_t a1 = pp[0];
  Double_t a2 = pp[1];
  Double_t s1 = pp[2];
  Double_t s2 = pp[3];
  return a1*(TMath::Gaus(x, 0, s1) - a2 * TMath::Gaus(x, 0, s2));
}

//=== Stuff for auto zooming =========================================
/** 
 * Update canvas range 
 * 
 * @param p Parameter 
 */
void UpdateRange(dNdetaDrawer::RangeParam* p)
{
  if (!p) { 
    Warning("UpdateRange", "No parameters %p", p);
    return;
  }
  if (!p->fMasterAxis) { 
    Warning("UpdateRange", "No master axis %p", p->fMasterAxis);
    return;
  }
  Int_t    first = p->fMasterAxis->GetFirst();
  Int_t    last  = p->fMasterAxis->GetLast();
  Double_t x1    = p->fMasterAxis->GetBinCenter(first);
  Double_t x2    = p->fMasterAxis->GetBinCenter(last);

  if (p->fSlave1Axis) { 
    Int_t i1 = p->fSlave1Axis->FindBin(x1);
    Int_t i2 = p->fSlave1Axis->FindBin(x2);
    p->fSlave1Axis->SetRange(i1, i2);
    p->fSlave1Pad->Modified();
    p->fSlave1Pad->Update();
  }
  if (p->fSlave2Axis) { 
    Int_t i1 = p->fSlave2Axis->FindBin(x1);
    Int_t i2 = p->fSlave2Axis->FindBin(x2);
    p->fSlave2Axis->SetRange(i1, i2);
    p->fSlave2Pad->Modified();
    p->fSlave2Pad->Update();
  }
  TCanvas*  c = gPad->GetCanvas();
  c->cd();
}
  
//____________________________________________________________________
/** 
 * Called when user changes X range 
 * 
 * @param p Parameter
 */
void RangeExec(dNdetaDrawer::RangeParam* p)
{
  // Event types: 
  //  51:   Mouse move 
  //  53:   
  //  1:    Button down 
  //  21:   Mouse drag
  //  11:   Mouse release 
  // dNdetaDrawer::RangeParam* p = 
  //   reinterpret_cast<dNdetaDrawer::RangeParam*>(addr);
  Int_t event     = gPad->GetEvent();
  TObject *select = gPad->GetSelected();
  if (event == 53) { 
    UpdateRange(p);
    return;
  }
  if (event != 11 || !select || select != p->fMasterAxis) return;
  UpdateRange(p);
}

//=== Steering functions
//==============================================  
/** 
 * Display usage information
 * 
 */
void
Usage()
{
  std::ostream& o = std::cout;
  o << "Usage: DrawdNdeta(FILE,TITLE,REBIN,OTHERS,FLAGS,"
    << "SNN,SYS,TRIG,IPZMIN,IPZMAX,BASE,FMT)\n"
    << "  const char* FILE   File name to open (\"forward_dndeta.root\")\n"
    << "  const char* TITLE  Title to put on plot (\"\")\n"
    << "  UShort_t    REBIN  Rebinning factor (1)\n"
    << "  UShort_t    OTHERS Other data to draw - more below (0x7)\n"
    << "  UShort_t    FLAGS  Visualisation flags - more below (0x7)\n"
    << "  UShort_t    SYS    (optional) 1:pp, 2:PbPb, 3:pPb\n"
    << "  UShort_t    SNN    (optional) sqrt(s_NN) in GeV\n"
    << "  UShort_t    TRIG   (optional) 1: INEL, 2: INEL>0, 4: NSD, ...\n"
    << "  Float_t     EFF    (optional) Trigger efficiency\n"
    << "  Float_t     IPZMIN (optional) Least z coordinate of IP\n"
    << "  Float_t     IPZMAX (optional) Largest z coordinate of IP\n"
    << "  const char* BASE   (optional) base name of output files\n"
    << "  UShort_t    FMT    (optional) Output formats\n"
    << "\n";
  o << " OTHERS is a bit mask of\n"
    << "  0x1     Show UA5 data (INEL,NSD, ppbar, 900GeV)\n"
    << "  0x2     Show CMS data (NSD, pp)\n"
    << "  0x4     Show published ALICE data (INEL,INEL>0,NSD, pp)\n"
    << "  0x8     Show event genertor data\n"
    << "\n";
  o << " FMT is a bit mask of\n"
    << "  0x1     Make PNG output\n"
    << "  0x2     Make PDF output\n"
    << "  0x4     Make ROOT file output\n"
    << "  0x8     Make ROOT script output\n"
    << "\n";
  o << " FLAGS is a bit mask of\n"
    << "  0x1     Show ratios of data to other data and possibly MC\n"
    << "  0x2     Show left-right asymmetry\n"
    << "  0x4     Show systematic error band\n"
    << "  0x8     Show individual ring results (INEL only)\n"
    << "  0x10    Cut edges when rebinning\n"
    << "  0x20    Remove FMDxO points\n"
    << "  0x40    Apply `final MC' correction\n"
    << "  0x80    Apply `Emperical' correction\n"
    << "  0x100   Force use of MB\n"
    << "  0x200   Mirror data\n"
    << "  0x400   Export results to script\n"
    << "  0x800   Add code to do combined zooms on eta axis\n"
    << "  0x1000  Assume old-style input\n"
    << "  0x2000  Be verbose\n"
    << "  0x4000  Hi-res batch output\n"
    << "  0x8000  Add aditional white-space above results\n"
    << "\n";
  o << "0x200 requires the file forward_dndetamc.root\n"
    << "0x400 requires the file EmpiricalCorrection.root\n"
    << "To specify that you want ratios, force MB, apply empirical "
    << "correction, and export to script, set flags to\n\n"
    << "   0x1|0x100|0x80|0x400=0x581\n"
    << std::endl;

}

//____________________________________________________________________
/** 
 * Draw @f$ dN/d\eta@f$ 
 * 
 * @param filename  File name 
 * @param title     Title 
 * @param rebin     Rebinning factor 
 * @param others    What other data to show 
 * @param flags     Flags 
 * @param sNN       (optional) Collision energy [GeV]
 * @param sys       (optional) Collision system (1: pp, 2: PbPb)
 * @param trg       (optional) Trigger (1: INEL, 2: INEL>0, 4: NSD)   
 * @param eff       (optional) Trigger efficiency 
 * @param vzMin     Least @f$ v_z@f$
 * @param vzMax     Largest @f$ v_z@f$
 * @param base      Base name 
 * @param outflg    Output flags 
 *
 * @ingroup pwglf_forward_dndeta
 */
void
DrawdNdeta(const char* filename="forward_dndeta.root", 
	   const char* title="",
	   UShort_t    rebin=5, 
	   UShort_t    others=0x7,
	   UInt_t      flags=dNdetaDrawer::kDefaultOptions,
	   UShort_t    sNN=0, 
	   UShort_t    sys=0,
	   UShort_t    trg=0,
	   Float_t     eff=0,
	   UShort_t    centMin=0,
	   UShort_t    centMax=100,
	   Float_t     vzMin=999, 
	   Float_t     vzMax=-999,
	   const char* base="", 
	   UShort_t    outflg=dNdetaDrawer::kAllFormats)
{
  TString fname(filename);
  fname.ToLower();
  if (fname.CompareTo("help") == 0 || 
      fname.CompareTo("--help") == 0) { 
    Usage();
    return;
  }
  dNdetaDrawer* pd = new dNdetaDrawer;
  pd->SetEmpirical("file://../empirical.root#default");
  // d.fClusterScale = "1.06 -0.003*x +0.0119*x*x";
  pd->Run(filename, title, rebin, others, flags, sys, sNN, trg, eff,
	  centMin, centMax, vzMin, vzMax, base, outflg);
}

/** 
 * Display usage information
 * 
 */
void
UsageS()
{
  std::ostream& o = std::cout;
  o << "Usage: DrawdNdeta(FILE,TITLE,OTHERS,OPTIONS,FORMATS,REBIN,EFF,"
    << "CMIN,CMAX,IPZMIN,IPZMAX,BASE)\n"
    << "  const char* FILE   File name to open (\"forward_dndeta.root\")\n"
    << "  const char* TITLE  Title to put on plot (\"\")\n"
    << "  const char* OTHERS Other data to draw - more below (\"all\")\n"
    << "  const char* FLAGS  Visualisation flags - more below (\"default\")\n"
    << "  const char* FMT    (optional) Output formats (\"all\")\n"
    << "  UShort_t    REBIN  (optional) Rebinning factor (5)\n"
    << "  Float_t     EFF    (optional) Trigger efficiency\n"
    << "  Float_t     IPZMIN (optional) Least z coordinate of IP\n"
    << "  Float_t     IPZMAX (optional) Largest z coordinate of IP\n"
    << "  UShort_t    CMIN   (optional) Least centrality\n"
    << "  UShort_t    CMAX   (optional) Largest centrality\n"
    << "  const char* BASE   (optional) base name of output files\n"
    << "\n";
  o << " OTHERS space separated list of\n"
    << "  UA5     Show UA5 data (INEL,NSD, ppbar, 900GeV)\n"
    << "  CMS     Show CMS data (NSD, pp)\n"
    << "  ALICE   Show published ALICE data (INEL,INEL>0,NSD, pp)\n"
    << "  WIP     Show event genertor data/work-in-progress\n"
    << "\n";
  o << " FMT space separated list of \n"
    << "  PNG     Make PNG output\n"
    << "  PDF     Make PDF output\n"
    << "  ROOT    Make ROOT file output\n"
    << "  C       Make ROOT script output\n"
    << "\n";
  o << " FLAGS is a bit mask of\n"
    << "  ratio           Show ratios of data to other data and possibly MC\n"
    << "  asymmetry       Show left-right asymmetry\n"
    << "  syserror        Show systematic error band\n"
    << "  rings           Show individual ring results (INEL only)\n"
    << "  noedges         Cut edges when rebinning\n"
    << "  noouters        Remove FMDxO points\n"
    << "  finalmc         Apply `final MC' correction\n"
    << "  empirical[=URL] Apply `Emperical' correction\n"
    << "  mb              Force use of MB\n"
    << "  mirror          Mirror data\n"
    << "  export          Export results to script\n"
    << "  exec            Add code to do combined zooms on eta axis\n"
    << "  old             Assume old-style input\n"
    << "  verbose         Be verbose\n"
    << "  hires           Hi-res batch output\n"
    << "  extrawhite      Add aditional white-space above results\n"
    << "  logo            Add ALICE logo\n"
    << "  nocentral       Do not plot cluster data\n"
    << "  nolabels        No labels on y-axis\n"
    << "\n";
  o << "finalmc requires the file forward_dndetamc.root\n"
    << "empirical requires the histogram at URL \n"
    << std::endl;

}

void 
Draw(const char* filename,
     const char* title="",
     const char* others="ALL",
     const char* options="DEFAULT",
     const char* outFlg="ALL",
     UShort_t    rebin=5,
     Float_t     eff=0, 
     UShort_t    centMin=0, 
     UShort_t    centMax=0, 
     Float_t     vzMin=+999,
     Float_t     vzMax=-999,
     const char* base="")
{
  TString fname(filename);
  fname.ToLower();
  if (fname.CompareTo("help") == 0 || 
      fname.CompareTo("--help") == 0) { 
    UsageS();
    return;
  }

  dNdetaDrawer* pd = new dNdetaDrawer;
  pd->SetEmpirical("file://../empirical.root#default");

  pd->Run(filename, title, others, options, outFlg, rebin, eff, 
	  centMin, centMax, vzMin, vzMax, base);
}
//____________________________________________________________________
//
// EOF
//

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