MuonTCMETValueMapProducer.cc

Go to the documentation of this file.

// -*- C++ -*-
//
// Package:    MuonTCMETValueMapProducer
// Class:      MuonTCMETValueMapProducer
// 
//
// Original Author:  Frank Golf
//         Created:  Sun Mar 15 11:33:20 CDT 2009
// $Id: MuonTCMETValueMapProducer.cc,v 1.6 2010/10/15 22:44:33 wmtan Exp $
//
//

// system include files
#include <memory>

// user include files
#include "RecoMET/METProducers/interface/MuonTCMETValueMapProducer.h"

#include "RecoMET/METAlgorithms/interface/TCMETAlgo.h"

#include "DataFormats/MuonReco/interface/Muon.h"
#include "DataFormats/BeamSpot/interface/BeamSpot.h"
#include "DataFormats/TrackReco/interface/Track.h"
#include "DataFormats/TrackReco/interface/TrackBase.h"
#include "DataFormats/TrackReco/interface/TrackFwd.h"
#include "DataFormats/Common/interface/ValueMap.h" 
#include "DataFormats/MuonReco/interface/MuonMETCorrectionData.h"
#include "DataFormats/GeometrySurface/interface/Plane.h"
#include "DataFormats/GeometrySurface/interface/Cylinder.h"
#include "DataFormats/GeometryVector/interface/GlobalPoint.h"
#include "DataFormats/GeometryVector/interface/GlobalVector.h"
#include "DataFormats/Math/interface/Point3D.h"

#include "MagneticField/Engine/interface/MagneticField.h"
#include "MagneticField/Records/interface/IdealMagneticFieldRecord.h"

#include "TrackingTools/TrajectoryState/interface/TrajectoryStateOnSurface.h"
#include "TrackingTools/GeomPropagators/interface/AnalyticalPropagator.h"

#include "Geometry/Records/interface/IdealGeometryRecord.h"
#include "FWCore/Framework/interface/MakerMacros.h"

#include "TH2D.h"
#include "TVector3.h"
#include "TMath.h"

typedef math::XYZTLorentzVector LorentzVector;
typedef math::XYZPoint Point;

namespace cms {
  MuonTCMETValueMapProducer::MuonTCMETValueMapProducer(const edm::ParameterSet& iConfig) {
  
    produces<edm::ValueMap<reco::MuonMETCorrectionData> > ("muCorrData");

    // get input collections
    muonInputTag_     = iConfig.getParameter<edm::InputTag>("muonInputTag"    );
    beamSpotInputTag_ = iConfig.getParameter<edm::InputTag>("beamSpotInputTag");
    vertexInputTag_   = iConfig.getParameter<edm::InputTag>("vertexInputTag");

    rfType_     = iConfig.getParameter<int>("rf_type");

    nLayers_                = iConfig.getParameter<int>      ("nLayers");
    nLayersTight_           = iConfig.getParameter<int>      ("nLayersTight");
    vertexNdof_             = iConfig.getParameter<int>      ("vertexNdof");
    vertexZ_                = iConfig.getParameter<double>   ("vertexZ");
    vertexRho_              = iConfig.getParameter<double>   ("vertexRho");
    vertexMaxDZ_            = iConfig.getParameter<double>   ("vertexMaxDZ");
    maxpt_eta20_            = iConfig.getParameter<double>   ("maxpt_eta20");
    maxpt_eta25_            = iConfig.getParameter<double>   ("maxpt_eta25");

    // get configuration parameters
    maxTrackAlgo_    = iConfig.getParameter<int>("trackAlgo_max");
    maxd0cut_        = iConfig.getParameter<double>("d0_max"       );
    minpt_           = iConfig.getParameter<double>("pt_min"       );
    maxpt_           = iConfig.getParameter<double>("pt_max"       );
    maxeta_          = iConfig.getParameter<double>("eta_max"      );
    maxchi2_         = iConfig.getParameter<double>("chi2_max"     );
    minhits_         = iConfig.getParameter<double>("nhits_min"    );
    maxPtErr_        = iConfig.getParameter<double>("ptErr_max"    );

    trkQuality_      = iConfig.getParameter<std::vector<int> >("track_quality");
    trkAlgos_        = iConfig.getParameter<std::vector<int> >("track_algos"  );
    maxchi2_tight_   = iConfig.getParameter<double>("chi2_max_tight");
    minhits_tight_   = iConfig.getParameter<double>("nhits_min_tight");
    maxPtErr_tight_  = iConfig.getParameter<double>("ptErr_max_tight");
    usePvtxd0_       = iConfig.getParameter<bool>("usePvtxd0");
    d0cuta_          = iConfig.getParameter<double>("d0cuta");
    d0cutb_          = iConfig.getParameter<double>("d0cutb");

    muon_dptrel_  = iConfig.getParameter<double>("muon_dptrel");
    muond0_     = iConfig.getParameter<double>("d0_muon"    );
    muonpt_     = iConfig.getParameter<double>("pt_muon"    );
    muoneta_    = iConfig.getParameter<double>("eta_muon"   );
    muonchi2_   = iConfig.getParameter<double>("chi2_muon"  );
    muonhits_   = iConfig.getParameter<double>("nhits_muon" );
    muonGlobal_   = iConfig.getParameter<bool>("global_muon");
    muonTracker_  = iConfig.getParameter<bool>("tracker_muon");
    muonDeltaR_ = iConfig.getParameter<double>("deltaR_muon");
    useCaloMuons_ = iConfig.getParameter<bool>("useCaloMuons");
    muonMinValidStaHits_ = iConfig.getParameter<int>("muonMinValidStaHits");

    response_function = 0;
  }

  MuonTCMETValueMapProducer::~MuonTCMETValueMapProducer()
  {
 
    // do anything here that needs to be done at desctruction time
    // (e.g. close files, deallocate resources etc.)

  }

  //
  // member functions
  //

  // ------------ method called to produce the data  ------------
  void MuonTCMETValueMapProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) {
  
    //get input collections
    iEvent.getByLabel(muonInputTag_    , muon_h    );
    iEvent.getByLabel(beamSpotInputTag_, beamSpot_h);

    //get vertex collection
    hasValidVertex = false;
    if( usePvtxd0_ ){
      iEvent.getByLabel( vertexInputTag_  , VertexHandle  );
       
      if( VertexHandle.isValid() ) {
        vertexColl = VertexHandle.product();
        hasValidVertex = isValidVertex();
      } 
    }

    //get the Bfield
    edm::ESHandle<MagneticField> theMagField;
    bool haveBfield = true;
    if( !theMagField.isValid() ) haveBfield = false;
    iSetup.get<IdealMagneticFieldRecord>().get(theMagField);
    bField = theMagField.product();

    //make a ValueMap of ints => flags for 
    //met correction. The values and meanings of the flags are :
    // flag==0 --->    The muon is not used to correct the MET by default
    // flag==1 --->    The muon is used to correct the MET. The Global pt is used.
    // flag==2 --->    The muon is used to correct the MET. The tracker pt is used.
    // flag==3 --->    The muon is used to correct the MET. The standalone pt is used.
    // flag==4 --->    The muon is used to correct the MET as pion using the tcMET ZSP RF.
    // flag==5 --->    The muon is used to correct the MET.  The default fit is used; i.e. we get the pt from muon->pt().
    // In general, the flag should never be 3. You do not want to correct the MET using
    // the pt measurement from the standalone system (unless you really know what you're 
    // doing

    std::auto_ptr<edm::ValueMap<reco::MuonMETCorrectionData> > vm_muCorrData(new edm::ValueMap<reco::MuonMETCorrectionData>());

    std::vector<reco::MuonMETCorrectionData> v_muCorrData;

    unsigned int nMuons = muon_h->size();

    for (unsigned int iMu = 0; iMu < nMuons; iMu++) {

      const reco::Muon* mu = &(*muon_h)[iMu];
      double deltax = 0.0;
      double deltay = 0.0;

      reco::MuonMETCorrectionData muMETCorrData(reco::MuonMETCorrectionData::NotUsed, deltax, deltay);
    
      reco::TrackRef mu_track;
      if( mu->isGlobalMuon() || mu->isTrackerMuon() || mu->isCaloMuon() )
        mu_track = mu->innerTrack();
      else {
        v_muCorrData.push_back( muMETCorrData );
        continue;
      }

      // figure out depositions muons would make if they were treated as pions
      if( isGoodTrack( mu ) ) {

        if( mu_track->pt() < minpt_ ) 
          muMETCorrData = reco::MuonMETCorrectionData(reco::MuonMETCorrectionData::TreatedAsPion, deltax, deltay);

        else {
          int bin_index   = response_function->FindBin( mu_track->eta(), mu_track->pt() );
          double response = response_function->GetBinContent( bin_index );

          TVector3 outerTrkPosition = propagateTrack( mu );

          deltax = response * mu_track->p() * sin( outerTrkPosition.Theta() ) * cos( outerTrkPosition.Phi() );
          deltay = response * mu_track->p() * sin( outerTrkPosition.Theta() ) * sin( outerTrkPosition.Phi() );

          muMETCorrData = reco::MuonMETCorrectionData(reco::MuonMETCorrectionData::TreatedAsPion, deltax, deltay);
        }
      }

      // figure out muon flag
      if( isGoodMuon( mu ) )
        v_muCorrData.push_back( reco::MuonMETCorrectionData(reco::MuonMETCorrectionData::MuonCandidateValuesUsed, deltax, deltay) );

      else if( useCaloMuons_ && isGoodCaloMuon( mu, iMu ) )
        v_muCorrData.push_back( reco::MuonMETCorrectionData(reco::MuonMETCorrectionData::MuonCandidateValuesUsed, deltax, deltay) );

      else v_muCorrData.push_back( muMETCorrData );
    }
    
    edm::ValueMap<reco::MuonMETCorrectionData>::Filler dataFiller(*vm_muCorrData);

    dataFiller.insert( muon_h, v_muCorrData.begin(), v_muCorrData.end());
    dataFiller.fill();
    
    iEvent.put(vm_muCorrData, "muCorrData");    
  }
  
  // ------------ method called once each job just before starting event loop  ------------
  void MuonTCMETValueMapProducer::beginJob()
  {

    if( rfType_ == 1 )
      response_function = getResponseFunction_fit();
    else if( rfType_ == 2 )
      response_function = getResponseFunction_mode();
  }

  // ------------ method called once each job just after ending the event loop  ------------
  void MuonTCMETValueMapProducer::endJob() {
  }

  // ------------ check is muon is a good muon  ------------
  bool MuonTCMETValueMapProducer::isGoodMuon( const reco::Muon* muon ) {
    double d0    = -999;
    double nhits = 0;
    double chi2  = 999;  

    // get d0 corrected for beam spot
    bool haveBeamSpot = true;
    if( !beamSpot_h.isValid() ) haveBeamSpot = false;

    if( muonGlobal_  && !muon->isGlobalMuon()  ) return false;
    if( muonTracker_ && !muon->isTrackerMuon() ) return false;

    const reco::TrackRef siTrack     = muon->innerTrack();
    const reco::TrackRef globalTrack = muon->globalTrack();

    Point bspot = haveBeamSpot ? beamSpot_h->position() : Point(0,0,0);
    if( siTrack.isNonnull() ) nhits = siTrack->numberOfValidHits();
    if( globalTrack.isNonnull() ) {
      d0   = -1 * globalTrack->dxy( bspot );
      chi2 = globalTrack->normalizedChi2();
    }

    if( fabs( d0 ) > muond0_ )                          return false;
    if( muon->pt() < muonpt_ )                          return false;
    if( fabs( muon->eta() ) > muoneta_ )                return false;
    if( nhits < muonhits_ )                             return false;
    if( chi2 > muonchi2_ )                              return false;
    if( globalTrack->hitPattern().numberOfValidMuonHits() < muonMinValidStaHits_ ) return false;

    //reject muons with tracker dpt/pt > X
    if( !siTrack.isNonnull() )                                return false;
    if( siTrack->ptError() / siTrack->pt() > muon_dptrel_ )   return false;

    else return true;
  }

  // ------------ check if muon is a good calo muon  ------------
  bool MuonTCMETValueMapProducer::isGoodCaloMuon( const reco::Muon* muon, const unsigned int index ) {

    if( muon->pt() < 10 ) return false;

    if( !isGoodTrack( muon ) ) return false;

    const reco::TrackRef inputSiliconTrack = muon->innerTrack();
    if( !inputSiliconTrack.isNonnull() ) return false;

    //check if it is in the vicinity of a global or tracker muon
    unsigned int nMuons = muon_h->size();
    for (unsigned int iMu = 0; iMu < nMuons; iMu++) {

      if( iMu == index ) continue;

      const reco::Muon* mu = &(*muon_h)[iMu];

      const reco::TrackRef testSiliconTrack = mu->innerTrack();
      if( !testSiliconTrack.isNonnull() ) continue;

      double deltaEta = inputSiliconTrack.get()->eta() - testSiliconTrack.get()->eta();
      double deltaPhi = acos( cos( inputSiliconTrack.get()->phi() - testSiliconTrack.get()->phi() ) );
      double deltaR   = TMath::Sqrt( deltaEta * deltaEta + deltaPhi * deltaPhi );

      if( deltaR < muonDeltaR_ ) return false;
    }

    return true;
  }

  // ------------ check if track is good  ------------
  bool MuonTCMETValueMapProducer::isGoodTrack( const reco::Muon* muon ) {
    double d0    = -999;

    const reco::TrackRef siTrack = muon->innerTrack();
    if (!siTrack.isNonnull())
      return false;

    if( hasValidVertex ){
      //get d0 corrected for primary vertex
            
      const Point pvtx = Point(vertexColl->begin()->x(),
                               vertexColl->begin()->y(), 
                               vertexColl->begin()->z());
            
      d0 = -1 * siTrack->dxy( pvtx );
            
      double dz = siTrack->dz( pvtx );
            
      if( fabs( dz ) < vertexMaxDZ_ ){
              
        //get d0 corrected for pvtx
        d0 = -1 * siTrack->dxy( pvtx );
              
      }else{
              
        // get d0 corrected for beam spot
        bool haveBeamSpot = true;
        if( !beamSpot_h.isValid() ) haveBeamSpot = false;
              
        Point bspot = haveBeamSpot ? beamSpot_h->position() : Point(0,0,0);
        d0 = -1 * siTrack->dxy( bspot );
              
      }
    }else{
       
      // get d0 corrected for beam spot
      bool haveBeamSpot = true;
      if( !beamSpot_h.isValid() ) haveBeamSpot = false;
       
      Point bspot = haveBeamSpot ? beamSpot_h->position() : Point(0,0,0);
      d0 = -1 * siTrack->dxy( bspot );
    }

    if( siTrack->algo() < maxTrackAlgo_ ){
      //1st 4 tracking iterations (pT-dependent d0 cut)
       
      float d0cut = sqrt(std::pow(d0cuta_,2) + std::pow(d0cutb_/siTrack->pt(),2)); 
      if(d0cut > maxd0cut_) d0cut = maxd0cut_;
       
      if( fabs( d0 ) > d0cut )            return false;    
      if( nLayers( siTrack ) < nLayers_ ) return false;
    }
    else{
      //last 2 tracking iterations (tighten chi2, nhits, pt error cuts)
     
      if( siTrack->normalizedChi2() > maxchi2_tight_ )               return false;
      if( siTrack->numberOfValidHits() < minhits_tight_ )            return false;
      if( (siTrack->ptError() / siTrack->pt()) > maxPtErr_tight_ )   return false;
      if( nLayers( siTrack ) < nLayersTight_ )                       return false;
    }

    if( siTrack->numberOfValidHits() < minhits_ )                         return false;
    if( siTrack->normalizedChi2() > maxchi2_ )                            return false;
    if( fabs( siTrack->eta() ) > maxeta_ )                                return false;
    if( siTrack->pt() > maxpt_ )                                          return false;
    if( (siTrack->ptError() / siTrack->pt()) > maxPtErr_ )                return false;
    if( fabs( siTrack->eta() ) > 2.5 && siTrack->pt() > maxpt_eta25_ )    return false;
    if( fabs( siTrack->eta() ) > 2.0 && siTrack->pt() > maxpt_eta20_ )    return false;

    int cut = 0;      
    for( unsigned int i = 0; i < trkQuality_.size(); i++ ) {

      cut |= (1 << trkQuality_.at(i));
    }

    if( !( (siTrack->qualityMask() & cut) == cut ) ) return false;
      
    bool isGoodAlgo = false;    
    if( trkAlgos_.size() == 0 ) isGoodAlgo = true;
    for( unsigned int i = 0; i < trkAlgos_.size(); i++ ) {

      if( siTrack->algo() == trkAlgos_.at(i) ) isGoodAlgo = true;
    }

    if( !isGoodAlgo ) return false;
      
    return true;
  }

  // ------------ propagate track to calorimeter face  ------------
  TVector3 MuonTCMETValueMapProducer::propagateTrack( const reco::Muon* muon) {

    TVector3 outerTrkPosition;

    outerTrkPosition.SetPtEtaPhi( 999., -10., 2 * TMath::Pi() );

    const reco::TrackRef track = muon->innerTrack();

    if( !track.isNonnull() ) {
      return outerTrkPosition;
    }

    GlobalPoint  tpVertex ( track->vx(), track->vy(), track->vz() );
    GlobalVector tpMomentum ( track.get()->px(), track.get()->py(), track.get()->pz() );
    int tpCharge ( track->charge() );

    FreeTrajectoryState fts ( tpVertex, tpMomentum, tpCharge, bField);

    const double zdist = 314.;

    const double radius = 130.;

    const double corner = 1.479;

    Plane::PlanePointer lendcap = Plane::build( Plane::PositionType (0, 0, -zdist), Plane::RotationType () );
    Plane::PlanePointer rendcap = Plane::build( Plane::PositionType (0, 0, zdist),  Plane::RotationType () );

    Cylinder::CylinderPointer barrel = Cylinder::build( Cylinder::PositionType (0, 0, 0), Cylinder::RotationType (), radius);

    AnalyticalPropagator myAP (bField, alongMomentum, 2*M_PI);

    TrajectoryStateOnSurface tsos;

    if( track.get()->eta() < -corner ) {
      tsos = myAP.propagate( fts, *lendcap);
    }
    else if( fabs(track.get()->eta()) < corner ) {
      tsos = myAP.propagate( fts, *barrel);
    }
    else if( track.get()->eta() > corner ) {
      tsos = myAP.propagate( fts, *rendcap);
    }

    if( tsos.isValid() )
      outerTrkPosition.SetXYZ( tsos.globalPosition().x(), tsos.globalPosition().y(), tsos.globalPosition().z() );

    else 
      outerTrkPosition.SetPtEtaPhi( 999., -10., 2 * TMath::Pi() );

    return outerTrkPosition;
  }

  // ------------ single pion response function from fit  ------------

  int MuonTCMETValueMapProducer::nLayers(const reco::TrackRef track){
    const reco::HitPattern& p = track->hitPattern();
    return p.trackerLayersWithMeasurement();
  }

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

  bool MuonTCMETValueMapProducer::isValidVertex(){
    
    if( vertexColl->begin()->isFake()                ) return false;
    if( vertexColl->begin()->ndof() < vertexNdof_    ) return false;
    if( fabs( vertexColl->begin()->z() ) > vertexZ_  ) return false;
    if( sqrt( std::pow( vertexColl->begin()->x() , 2 ) + std::pow( vertexColl->begin()->y() , 2 ) ) > vertexRho_ ) return false;
    
    return true;
    
  }

  // ------------ single pion response function from fit  ------------
  TH2D* MuonTCMETValueMapProducer::getResponseFunction_fit() {

    Double_t xAxis1[53] = {-2.5, -2.322, -2.172, -2.043, -1.93, -1.83, 
                           -1.74, -1.653, -1.566, -1.479, -1.392, -1.305, 
                           -1.218, -1.131, -1.044, -0.957, -0.879, -0.783, 
                           -0.696, -0.609, -0.522, -0.435, -0.348, -0.261, 
                           -0.174, -0.087, 0, 0.087, 0.174, 0.261, 0.348, 
                           0.435, 0.522, 0.609, 0.696, 0.783, 0.879, 0.957, 
                           1.044, 1.131, 1.218, 1.305, 1.392, 1.479, 1.566, 
                           1.653, 1.74, 1.83, 1.93, 2.043, 2.172, 2.322, 2.5}; 
  
    Double_t yAxis1[29] = {0, 0.5, 1, 1.5, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 14,
                           16, 18, 20, 25, 30, 35, 40, 45, 50, 60, 70, 80, 90, 100}; 
   
    TH2D *hrf = new TH2D("hrf","RF  (fit)",52, xAxis1,28, yAxis1);


     hrf->SetBinContent(55,0.9014105);
     hrf->SetBinContent(56,1.234047);
     hrf->SetBinContent(57,1.404987);
     hrf->SetBinContent(58,1.576149);
     hrf->SetBinContent(59,1.677449);
     hrf->SetBinContent(60,1.419812);
     hrf->SetBinContent(61,1.318056);
     hrf->SetBinContent(62,1.287693);
     hrf->SetBinContent(63,1.158259);
     hrf->SetBinContent(64,8.160139e-14);
     hrf->SetBinContent(65,0.9419115);
     hrf->SetBinContent(66,2.235989e-13);
     hrf->SetBinContent(67,0.4986045);
     hrf->SetBinContent(68,2.420397e-12);
     hrf->SetBinContent(69,6.139533e-14);
     hrf->SetBinContent(70,6.894485e-13);
     hrf->SetBinContent(71,3.603784e-13);
     hrf->SetBinContent(72,3.894685e-11);
     hrf->SetBinContent(73,2.43805e-13);
     hrf->SetBinContent(74,0.78136);
     hrf->SetBinContent(75,0.9358564);
     hrf->SetBinContent(76,5.687018e-11);
     hrf->SetBinContent(77,8.881784e-16);
     hrf->SetBinContent(78,1.287748e-12);
     hrf->SetBinContent(79,1.624256e-13);
     hrf->SetBinContent(80,1.099121e-14);
     hrf->SetBinContent(81,3.390954e-12);
     hrf->SetBinContent(82,2.581269e-13);
     hrf->SetBinContent(83,7.549517e-15);
     hrf->SetBinContent(84,6.168399e-13);
     hrf->SetBinContent(85,1.135092e-11);
     hrf->SetBinContent(86,2.553513e-15);
     hrf->SetBinContent(87,0.2588152);
     hrf->SetBinContent(88,1.04361e-14);
     hrf->SetBinContent(89,0.7345221);
     hrf->SetBinContent(90,1.224243e-12);
     hrf->SetBinContent(91,1.110223e-16);
     hrf->SetBinContent(92,8.375522e-13);
     hrf->SetBinContent(93,1.509903e-14);
     hrf->SetBinContent(94,3.907652e-12);
     hrf->SetBinContent(95,1.110223e-16);
     hrf->SetBinContent(96,0.8778926);
     hrf->SetBinContent(97,5.440093e-15);
     hrf->SetBinContent(98,1.254552e-14);
     hrf->SetBinContent(99,0.9284989);
     hrf->SetBinContent(100,0.753942);
     hrf->SetBinContent(101,1.103987);
     hrf->SetBinContent(102,1.188931);
     hrf->SetBinContent(103,1.080741);
     hrf->SetBinContent(104,1.123484);
     hrf->SetBinContent(105,0.96811);
     hrf->SetBinContent(106,0.8889167);
     hrf->SetBinContent(109,0.6210886);
     hrf->SetBinContent(110,0.7505165);
     hrf->SetBinContent(111,0.8426157);
     hrf->SetBinContent(112,0.8893985);
     hrf->SetBinContent(113,0.8655712);
     hrf->SetBinContent(114,0.8169596);
     hrf->SetBinContent(115,0.7972677);
     hrf->SetBinContent(116,0.6298301);
     hrf->SetBinContent(117,0.5066007);
     hrf->SetBinContent(118,4.480217e-10);
     hrf->SetBinContent(119,1.064704e-13);
     hrf->SetBinContent(120,6.32161e-13);
     hrf->SetBinContent(121,0.3865254);
     hrf->SetBinContent(122,4.662937e-15);
     hrf->SetBinContent(123,2.523537e-13);
     hrf->SetBinContent(124,3.441691e-15);
     hrf->SetBinContent(125,1.539324e-12);
     hrf->SetBinContent(126,0.5198836);
     hrf->SetBinContent(127,3.774758e-15);
     hrf->SetBinContent(128,4.662937e-15);
     hrf->SetBinContent(129,5.095924e-13);
     hrf->SetBinContent(130,8.992806e-15);
     hrf->SetBinContent(131,0.6979459);
     hrf->SetBinContent(132,0.8410133);
     hrf->SetBinContent(133,0.8820518);
     hrf->SetBinContent(134,1.449095e-09);
     hrf->SetBinContent(135,1.891825);
     hrf->SetBinContent(136,3.736567e-12);
     hrf->SetBinContent(137,2.171596e-13);
     hrf->SetBinContent(138,3.58602e-14);
     hrf->SetBinContent(139,8.401058e-13);
     hrf->SetBinContent(140,6.661338e-16);
     hrf->SetBinContent(141,6.228351e-14);
     hrf->SetBinContent(142,4.440892e-16);
     hrf->SetBinContent(143,0.5043001);
     hrf->SetBinContent(144,2.950751e-12);
     hrf->SetBinContent(145,7.44127e-12);
     hrf->SetBinContent(146,4.440892e-16);
     hrf->SetBinContent(147,0.415431);
     hrf->SetBinContent(148,0.3341262);
     hrf->SetBinContent(149,5.917489e-14);
     hrf->SetBinContent(150,5.551115e-15);
     hrf->SetBinContent(151,3.733125e-12);
     hrf->SetBinContent(152,2.220446e-16);
     hrf->SetBinContent(153,0.5875186);
     hrf->SetBinContent(154,0.6020446);
     hrf->SetBinContent(155,0.6340457);
     hrf->SetBinContent(156,0.6748299);
     hrf->SetBinContent(157,0.7500966);
     hrf->SetBinContent(158,0.6613656);
     hrf->SetBinContent(159,0.5764616);
     hrf->SetBinContent(160,0.5013173);
     hrf->SetBinContent(163,0.6392601);
     hrf->SetBinContent(164,0.7223623);
     hrf->SetBinContent(165,0.7522092);
     hrf->SetBinContent(166,0.7454079);
     hrf->SetBinContent(167,0.6907078);
     hrf->SetBinContent(168,0.5840503);
     hrf->SetBinContent(169,0.5802541);
     hrf->SetBinContent(170,0.4497995);
     hrf->SetBinContent(171,0.3261);
     hrf->SetBinContent(172,0.2172562);
     hrf->SetBinContent(173,0.04889038);
     hrf->SetBinContent(174,0.1511836);
     hrf->SetBinContent(175,0.1596252);
     hrf->SetBinContent(176,0.2589621);
     hrf->SetBinContent(177,4.440892e-16);
     hrf->SetBinContent(178,1.110223e-16);
     hrf->SetBinContent(180,1.733058e-13);
     hrf->SetBinContent(181,3.145262e-13);
     hrf->SetBinContent(182,0.3940507);
     hrf->SetBinContent(183,0.4929505);
     hrf->SetBinContent(186,8.437695e-14);
     hrf->SetBinContent(187,4.527934e-12);
     hrf->SetBinContent(188,3.481881e-12);
     hrf->SetBinContent(189,1.54321e-14);
     hrf->SetBinContent(190,1.998401e-15);
     hrf->SetBinContent(191,2.557732e-12);
     hrf->SetBinContent(192,5.314638e-13);
     hrf->SetBinContent(193,1.465827e-12);
     hrf->SetBinContent(194,0.4952829);
     hrf->SetBinContent(195,0.3710457);
     hrf->SetBinContent(196,7.058798e-13);
     hrf->SetBinContent(197,1.065814e-14);
     hrf->SetBinContent(198,3.330669e-16);
     hrf->SetBinContent(199,3.552714e-15);
     hrf->SetBinContent(200,2.58682e-14);
     hrf->SetBinContent(201,3.330669e-16);
     hrf->SetBinContent(202,0.2388499);
     hrf->SetBinContent(203,1.232681e-12);
     hrf->SetBinContent(204,3.28626e-14);
     hrf->SetBinContent(205,4.372058e-13);
     hrf->SetBinContent(206,1.764622e-11);
     hrf->SetBinContent(207,0.2737416);
     hrf->SetBinContent(208,0.3558382);
     hrf->SetBinContent(209,0.4365672);
     hrf->SetBinContent(210,0.5245328);
     hrf->SetBinContent(211,0.5426048);
     hrf->SetBinContent(212,0.5763847);
     hrf->SetBinContent(213,0.5997939);
     hrf->SetBinContent(214,0.5647634);
     hrf->SetBinContent(217,0.6166065);
     hrf->SetBinContent(218,0.6904591);
     hrf->SetBinContent(219,0.7446713);
     hrf->SetBinContent(220,0.7428927);
     hrf->SetBinContent(221,0.7014583);
     hrf->SetBinContent(222,0.6360658);
     hrf->SetBinContent(223,0.5507807);
     hrf->SetBinContent(224,0.4662885);
     hrf->SetBinContent(225,0.2921537);
     hrf->SetBinContent(226,0.2622769);
     hrf->SetBinContent(227,0.2209838);
     hrf->SetBinContent(228,0.109091);
     hrf->SetBinContent(229,5.329071e-15);
     hrf->SetBinContent(230,9.55902e-14);
     hrf->SetBinContent(231,0.09094051);
     hrf->SetBinContent(232,0.2690939);
     hrf->SetBinContent(233,0.3311066);
     hrf->SetBinContent(234,0.3870305);
     hrf->SetBinContent(235,4.851675e-14);
     hrf->SetBinContent(236,7.41629e-14);
     hrf->SetBinContent(237,5.551115e-16);
     hrf->SetBinContent(238,1.665335e-15);
     hrf->SetBinContent(239,3.900213e-13);
     hrf->SetBinContent(240,3.986922e-12);
     hrf->SetBinContent(241,0.07189925);
     hrf->SetBinContent(242,5.363154e-11);
     hrf->SetBinContent(243,0.1681561);
     hrf->SetBinContent(244,5.77316e-15);
     hrf->SetBinContent(245,1.393652e-11);
     hrf->SetBinContent(246,8.91287e-13);
     hrf->SetBinContent(247,3.08642e-14);
     hrf->SetBinContent(248,6.882273e-13);
     hrf->SetBinContent(249,2.220446e-15);
     hrf->SetBinContent(250,1.69631e-12);
     hrf->SetBinContent(251,0.3618142);
     hrf->SetBinContent(252,0.3173401);
     hrf->SetBinContent(253,0.2427478);
     hrf->SetBinContent(254,0.04446017);
     hrf->SetBinContent(255,4.011236e-13);
     hrf->SetBinContent(256,2.68674e-14);
     hrf->SetBinContent(257,1.39222e-13);
     hrf->SetBinContent(258,2.775558e-13);
     hrf->SetBinContent(259,4.662937e-15);
     hrf->SetBinContent(260,0.01799486);
     hrf->SetBinContent(261,0.2536237);
     hrf->SetBinContent(262,0.4121629);
     hrf->SetBinContent(263,0.5030896);
     hrf->SetBinContent(264,0.5291037);
     hrf->SetBinContent(265,0.5938131);
     hrf->SetBinContent(266,0.6105046);
     hrf->SetBinContent(267,0.5962813);
     hrf->SetBinContent(268,0.5595579);
     hrf->SetBinContent(271,0.6526371);
     hrf->SetBinContent(272,0.6718102);
     hrf->SetBinContent(273,0.6971064);
     hrf->SetBinContent(274,0.715696);
     hrf->SetBinContent(275,0.6756563);
     hrf->SetBinContent(276,0.6536352);
     hrf->SetBinContent(277,0.6298154);
     hrf->SetBinContent(278,0.5889418);
     hrf->SetBinContent(279,0.5101216);
     hrf->SetBinContent(280,0.4338073);
     hrf->SetBinContent(281,0.4037817);
     hrf->SetBinContent(282,0.3741269);
     hrf->SetBinContent(283,0.3506718);
     hrf->SetBinContent(284,0.3315757);
     hrf->SetBinContent(285,0.3424355);
     hrf->SetBinContent(286,0.3468707);
     hrf->SetBinContent(287,0.3521713);
     hrf->SetBinContent(288,0.3655425);
     hrf->SetBinContent(289,0.3903866);
     hrf->SetBinContent(290,0.42171);
     hrf->SetBinContent(291,0.4440749);
     hrf->SetBinContent(292,0.436104);
     hrf->SetBinContent(293,0.4834715);
     hrf->SetBinContent(294,0.4727529);
     hrf->SetBinContent(295,0.503675);
     hrf->SetBinContent(296,0.5256206);
     hrf->SetBinContent(297,0.5077537);
     hrf->SetBinContent(298,0.5060191);
     hrf->SetBinContent(299,0.4839341);
     hrf->SetBinContent(300,0.4730944);
     hrf->SetBinContent(301,0.4377449);
     hrf->SetBinContent(302,0.4008532);
     hrf->SetBinContent(303,0.3935297);
     hrf->SetBinContent(304,0.3723053);
     hrf->SetBinContent(305,0.3553247);
     hrf->SetBinContent(306,0.3426032);
     hrf->SetBinContent(307,0.3302374);
     hrf->SetBinContent(308,0.3205566);
     hrf->SetBinContent(309,0.3008779);
     hrf->SetBinContent(310,0.3194912);
     hrf->SetBinContent(311,0.3341432);
     hrf->SetBinContent(312,0.3293249);
     hrf->SetBinContent(313,0.3298494);
     hrf->SetBinContent(314,0.376054);
     hrf->SetBinContent(315,0.4665582);
     hrf->SetBinContent(316,0.4961285);
     hrf->SetBinContent(317,0.5445178);
     hrf->SetBinContent(318,0.5630735);
     hrf->SetBinContent(319,0.5911169);
     hrf->SetBinContent(320,0.6053321);
     hrf->SetBinContent(321,0.6138202);
     hrf->SetBinContent(322,0.5993208);
     hrf->SetBinContent(325,0.7072042);
     hrf->SetBinContent(326,0.7170147);
     hrf->SetBinContent(327,0.7079694);
     hrf->SetBinContent(328,0.7087873);
     hrf->SetBinContent(329,0.6794895);
     hrf->SetBinContent(330,0.6620911);
     hrf->SetBinContent(331,0.6368085);
     hrf->SetBinContent(332,0.6167822);
     hrf->SetBinContent(333,0.5804145);
     hrf->SetBinContent(334,0.5311387);
     hrf->SetBinContent(335,0.4996493);
     hrf->SetBinContent(336,0.4774897);
     hrf->SetBinContent(337,0.4508032);
     hrf->SetBinContent(338,0.4407316);
     hrf->SetBinContent(339,0.4488528);
     hrf->SetBinContent(340,0.4668958);
     hrf->SetBinContent(341,0.4631993);
     hrf->SetBinContent(342,0.4832653);
     hrf->SetBinContent(343,0.5049595);
     hrf->SetBinContent(344,0.5156142);
     hrf->SetBinContent(345,0.5251185);
     hrf->SetBinContent(346,0.5349182);
     hrf->SetBinContent(347,0.5429661);
     hrf->SetBinContent(348,0.5488337);
     hrf->SetBinContent(349,0.5663636);
     hrf->SetBinContent(350,0.5653254);
     hrf->SetBinContent(351,0.5707994);
     hrf->SetBinContent(352,0.5582824);
     hrf->SetBinContent(353,0.5500923);
     hrf->SetBinContent(354,0.5360044);
     hrf->SetBinContent(355,0.5443032);
     hrf->SetBinContent(356,0.5130047);
     hrf->SetBinContent(357,0.496836);
     hrf->SetBinContent(358,0.5037468);
     hrf->SetBinContent(359,0.4914352);
     hrf->SetBinContent(360,0.4690715);
     hrf->SetBinContent(361,0.4548738);
     hrf->SetBinContent(362,0.4484025);
     hrf->SetBinContent(363,0.4367421);
     hrf->SetBinContent(364,0.4432692);
     hrf->SetBinContent(365,0.4540293);
     hrf->SetBinContent(366,0.4528085);
     hrf->SetBinContent(367,0.4793456);
     hrf->SetBinContent(368,0.5333259);
     hrf->SetBinContent(369,0.5224165);
     hrf->SetBinContent(370,0.5335762);
     hrf->SetBinContent(371,0.5766528);
     hrf->SetBinContent(372,0.5914772);
     hrf->SetBinContent(373,0.6361837);
     hrf->SetBinContent(374,0.6511061);
     hrf->SetBinContent(375,0.6729068);
     hrf->SetBinContent(376,0.6693861);
     hrf->SetBinContent(379,0.749916);
     hrf->SetBinContent(380,0.7597389);
     hrf->SetBinContent(381,0.7507262);
     hrf->SetBinContent(382,0.7387256);
     hrf->SetBinContent(383,0.7146781);
     hrf->SetBinContent(384,0.6706957);
     hrf->SetBinContent(385,0.6562388);
     hrf->SetBinContent(386,0.6451488);
     hrf->SetBinContent(387,0.6257445);
     hrf->SetBinContent(388,0.5541511);
     hrf->SetBinContent(389,0.5267816);
     hrf->SetBinContent(390,0.5050932);
     hrf->SetBinContent(391,0.498381);
     hrf->SetBinContent(392,0.4985682);
     hrf->SetBinContent(393,0.5024638);
     hrf->SetBinContent(394,0.5153883);
     hrf->SetBinContent(395,0.5194017);
     hrf->SetBinContent(396,0.5463501);
     hrf->SetBinContent(397,0.5520073);
     hrf->SetBinContent(398,0.5520941);
     hrf->SetBinContent(399,0.5610467);
     hrf->SetBinContent(400,0.5676893);
     hrf->SetBinContent(401,0.5760659);
     hrf->SetBinContent(402,0.5787081);
     hrf->SetBinContent(403,0.6006499);
     hrf->SetBinContent(404,0.6000866);
     hrf->SetBinContent(405,0.606465);
     hrf->SetBinContent(406,0.5974886);
     hrf->SetBinContent(407,0.5776305);
     hrf->SetBinContent(408,0.5754585);
     hrf->SetBinContent(409,0.5686907);
     hrf->SetBinContent(410,0.5632511);
     hrf->SetBinContent(411,0.5433577);
     hrf->SetBinContent(412,0.5414782);
     hrf->SetBinContent(413,0.5409556);
     hrf->SetBinContent(414,0.5249445);
     hrf->SetBinContent(415,0.509481);
     hrf->SetBinContent(416,0.4860629);
     hrf->SetBinContent(417,0.4814033);
     hrf->SetBinContent(418,0.4881889);
     hrf->SetBinContent(419,0.4892032);
     hrf->SetBinContent(420,0.4967099);
     hrf->SetBinContent(421,0.5080456);
     hrf->SetBinContent(422,0.5725561);
     hrf->SetBinContent(423,0.5688643);
     hrf->SetBinContent(424,0.5783035);
     hrf->SetBinContent(425,0.608463);
     hrf->SetBinContent(426,0.6477233);
     hrf->SetBinContent(427,0.678503);
     hrf->SetBinContent(428,0.6974414);
     hrf->SetBinContent(429,0.7161245);
     hrf->SetBinContent(430,0.7179291);
     hrf->SetBinContent(433,0.7649254);
     hrf->SetBinContent(434,0.7875582);
     hrf->SetBinContent(435,0.7829209);
     hrf->SetBinContent(436,0.7632096);
     hrf->SetBinContent(437,0.7486479);
     hrf->SetBinContent(438,0.7155891);
     hrf->SetBinContent(439,0.681989);
     hrf->SetBinContent(440,0.6651565);
     hrf->SetBinContent(441,0.6493679);
     hrf->SetBinContent(442,0.5650414);
     hrf->SetBinContent(443,0.5358658);
     hrf->SetBinContent(444,0.5266296);
     hrf->SetBinContent(445,0.5113901);
     hrf->SetBinContent(446,0.5254153);
     hrf->SetBinContent(447,0.5273484);
     hrf->SetBinContent(448,0.5369164);
     hrf->SetBinContent(449,0.5409524);
     hrf->SetBinContent(450,0.5658296);
     hrf->SetBinContent(451,0.5776091);
     hrf->SetBinContent(452,0.5741496);
     hrf->SetBinContent(453,0.5962785);
     hrf->SetBinContent(454,0.5996542);
     hrf->SetBinContent(455,0.5980803);
     hrf->SetBinContent(456,0.6063);
     hrf->SetBinContent(457,0.6241938);
     hrf->SetBinContent(458,0.6266866);
     hrf->SetBinContent(459,0.6175104);
     hrf->SetBinContent(460,0.6188141);
     hrf->SetBinContent(461,0.6151288);
     hrf->SetBinContent(462,0.5934609);
     hrf->SetBinContent(463,0.590576);
     hrf->SetBinContent(464,0.5800966);
     hrf->SetBinContent(465,0.5787441);
     hrf->SetBinContent(466,0.5729356);
     hrf->SetBinContent(467,0.5677129);
     hrf->SetBinContent(468,0.5537542);
     hrf->SetBinContent(469,0.5355842);
     hrf->SetBinContent(470,0.5196738);
     hrf->SetBinContent(471,0.5210825);
     hrf->SetBinContent(472,0.5059826);
     hrf->SetBinContent(473,0.5146358);
     hrf->SetBinContent(474,0.5194442);
     hrf->SetBinContent(475,0.5423242);
     hrf->SetBinContent(476,0.6041303);
     hrf->SetBinContent(477,0.6131922);
     hrf->SetBinContent(478,0.6294447);
     hrf->SetBinContent(479,0.6581404);
     hrf->SetBinContent(480,0.682565);
     hrf->SetBinContent(481,0.7175475);
     hrf->SetBinContent(482,0.732161);
     hrf->SetBinContent(483,0.7473059);
     hrf->SetBinContent(484,0.7463843);
     hrf->SetBinContent(487,0.7733338);
     hrf->SetBinContent(488,0.7914098);
     hrf->SetBinContent(489,0.7922547);
     hrf->SetBinContent(490,0.7975932);
     hrf->SetBinContent(491,0.7624868);
     hrf->SetBinContent(492,0.7416359);
     hrf->SetBinContent(493,0.723097);
     hrf->SetBinContent(494,0.7061391);
     hrf->SetBinContent(495,0.6900467);
     hrf->SetBinContent(496,0.6053169);
     hrf->SetBinContent(497,0.5709425);
     hrf->SetBinContent(498,0.5451863);
     hrf->SetBinContent(499,0.5321503);
     hrf->SetBinContent(500,0.5324251);
     hrf->SetBinContent(501,0.5397416);
     hrf->SetBinContent(502,0.575781);
     hrf->SetBinContent(503,0.5632829);
     hrf->SetBinContent(504,0.5976698);
     hrf->SetBinContent(505,0.5966061);
     hrf->SetBinContent(506,0.6016284);
     hrf->SetBinContent(507,0.5992189);
     hrf->SetBinContent(508,0.6216044);
     hrf->SetBinContent(509,0.6149693);
     hrf->SetBinContent(510,0.6312055);
     hrf->SetBinContent(511,0.6368536);
     hrf->SetBinContent(512,0.6376288);
     hrf->SetBinContent(513,0.6294262);
     hrf->SetBinContent(514,0.6308918);
     hrf->SetBinContent(515,0.6290194);
     hrf->SetBinContent(516,0.6216436);
     hrf->SetBinContent(517,0.6144779);
     hrf->SetBinContent(518,0.6137364);
     hrf->SetBinContent(519,0.6026688);
     hrf->SetBinContent(520,0.6069801);
     hrf->SetBinContent(521,0.5848015);
     hrf->SetBinContent(522,0.5748533);
     hrf->SetBinContent(523,0.5508263);
     hrf->SetBinContent(524,0.5483323);
     hrf->SetBinContent(525,0.5322801);
     hrf->SetBinContent(526,0.5254273);
     hrf->SetBinContent(527,0.5410626);
     hrf->SetBinContent(528,0.5529507);
     hrf->SetBinContent(529,0.5857173);
     hrf->SetBinContent(530,0.6527883);
     hrf->SetBinContent(531,0.6530318);
     hrf->SetBinContent(532,0.6672208);
     hrf->SetBinContent(533,0.7044364);
     hrf->SetBinContent(534,0.7190105);
     hrf->SetBinContent(535,0.7483566);
     hrf->SetBinContent(536,0.7548751);
     hrf->SetBinContent(537,0.7652832);
     hrf->SetBinContent(538,0.7529632);
     hrf->SetBinContent(541,0.779761);
     hrf->SetBinContent(542,0.7991457);
     hrf->SetBinContent(543,0.8038527);
     hrf->SetBinContent(544,0.7977124);
     hrf->SetBinContent(545,0.7917452);
     hrf->SetBinContent(546,0.7720835);
     hrf->SetBinContent(547,0.7327496);
     hrf->SetBinContent(548,0.7359458);
     hrf->SetBinContent(549,0.7209811);
     hrf->SetBinContent(550,0.6282369);
     hrf->SetBinContent(551,0.6037263);
     hrf->SetBinContent(552,0.5729901);
     hrf->SetBinContent(553,0.5664849);
     hrf->SetBinContent(554,0.5590503);
     hrf->SetBinContent(555,0.5610377);
     hrf->SetBinContent(556,0.5755157);
     hrf->SetBinContent(557,0.5890701);
     hrf->SetBinContent(558,0.6107467);
     hrf->SetBinContent(559,0.6061065);
     hrf->SetBinContent(560,0.6135439);
     hrf->SetBinContent(561,0.6336191);
     hrf->SetBinContent(562,0.6395465);
     hrf->SetBinContent(563,0.6450207);
     hrf->SetBinContent(564,0.6457672);
     hrf->SetBinContent(565,0.6570385);
     hrf->SetBinContent(566,0.6614696);
     hrf->SetBinContent(567,0.6429687);
     hrf->SetBinContent(568,0.6491577);
     hrf->SetBinContent(569,0.6464563);
     hrf->SetBinContent(570,0.6443511);
     hrf->SetBinContent(571,0.6264946);
     hrf->SetBinContent(572,0.6210324);
     hrf->SetBinContent(573,0.6074563);
     hrf->SetBinContent(574,0.6162496);
     hrf->SetBinContent(575,0.6052733);
     hrf->SetBinContent(576,0.5810783);
     hrf->SetBinContent(577,0.5706381);
     hrf->SetBinContent(578,0.5627378);
     hrf->SetBinContent(579,0.5527847);
     hrf->SetBinContent(580,0.5641665);
     hrf->SetBinContent(581,0.5694626);
     hrf->SetBinContent(582,0.5749119);
     hrf->SetBinContent(583,0.6263555);
     hrf->SetBinContent(584,0.7097491);
     hrf->SetBinContent(585,0.6947002);
     hrf->SetBinContent(586,0.7008479);
     hrf->SetBinContent(587,0.7207282);
     hrf->SetBinContent(588,0.7500328);
     hrf->SetBinContent(589,0.7644583);
     hrf->SetBinContent(590,0.7729988);
     hrf->SetBinContent(591,0.774512);
     hrf->SetBinContent(592,0.766691);
     hrf->SetBinContent(595,0.7877997);
     hrf->SetBinContent(596,0.808685);
     hrf->SetBinContent(597,0.8098472);
     hrf->SetBinContent(598,0.7990698);
     hrf->SetBinContent(599,0.7913377);
     hrf->SetBinContent(600,0.7841092);
     hrf->SetBinContent(601,0.7699786);
     hrf->SetBinContent(602,0.7508966);
     hrf->SetBinContent(603,0.7446558);
     hrf->SetBinContent(604,0.6604987);
     hrf->SetBinContent(605,0.6226556);
     hrf->SetBinContent(606,0.6059709);
     hrf->SetBinContent(607,0.5917993);
     hrf->SetBinContent(608,0.5969635);
     hrf->SetBinContent(609,0.5934169);
     hrf->SetBinContent(610,0.5916147);
     hrf->SetBinContent(611,0.6020344);
     hrf->SetBinContent(612,0.617125);
     hrf->SetBinContent(613,0.6127092);
     hrf->SetBinContent(614,0.6242438);
     hrf->SetBinContent(615,0.6382228);
     hrf->SetBinContent(616,0.6551722);
     hrf->SetBinContent(617,0.6591862);
     hrf->SetBinContent(618,0.6545591);
     hrf->SetBinContent(619,0.6651771);
     hrf->SetBinContent(620,0.6659877);
     hrf->SetBinContent(621,0.6619171);
     hrf->SetBinContent(622,0.6770883);
     hrf->SetBinContent(623,0.6546994);
     hrf->SetBinContent(624,0.6580142);
     hrf->SetBinContent(625,0.6535073);
     hrf->SetBinContent(626,0.6343181);
     hrf->SetBinContent(627,0.6272753);
     hrf->SetBinContent(628,0.6205974);
     hrf->SetBinContent(629,0.6180187);
     hrf->SetBinContent(630,0.5955703);
     hrf->SetBinContent(631,0.5950559);
     hrf->SetBinContent(632,0.5859662);
     hrf->SetBinContent(633,0.5825738);
     hrf->SetBinContent(634,0.5839396);
     hrf->SetBinContent(635,0.59145);
     hrf->SetBinContent(636,0.6092284);
     hrf->SetBinContent(637,0.6343765);
     hrf->SetBinContent(638,0.7176949);
     hrf->SetBinContent(639,0.7168224);
     hrf->SetBinContent(640,0.7343724);
     hrf->SetBinContent(641,0.7428303);
     hrf->SetBinContent(642,0.7552095);
     hrf->SetBinContent(643,0.7756618);
     hrf->SetBinContent(644,0.7788388);
     hrf->SetBinContent(645,0.7845942);
     hrf->SetBinContent(646,0.7718939);
     hrf->SetBinContent(649,0.7944824);
     hrf->SetBinContent(650,0.8055041);
     hrf->SetBinContent(651,0.8163133);
     hrf->SetBinContent(652,0.8026978);
     hrf->SetBinContent(653,0.790246);
     hrf->SetBinContent(654,0.7957031);
     hrf->SetBinContent(655,0.7770987);
     hrf->SetBinContent(656,0.7683768);
     hrf->SetBinContent(657,0.7810934);
     hrf->SetBinContent(658,0.6743879);
     hrf->SetBinContent(659,0.6436225);
     hrf->SetBinContent(660,0.632295);
     hrf->SetBinContent(661,0.6136842);
     hrf->SetBinContent(662,0.6152433);
     hrf->SetBinContent(663,0.6258261);
     hrf->SetBinContent(664,0.6237895);
     hrf->SetBinContent(665,0.6237429);
     hrf->SetBinContent(666,0.6365916);
     hrf->SetBinContent(667,0.6370676);
     hrf->SetBinContent(668,0.6374596);
     hrf->SetBinContent(669,0.6477762);
     hrf->SetBinContent(670,0.6613339);
     hrf->SetBinContent(671,0.6717926);
     hrf->SetBinContent(672,0.6676553);
     hrf->SetBinContent(673,0.6750093);
     hrf->SetBinContent(674,0.6722414);
     hrf->SetBinContent(675,0.6776585);
     hrf->SetBinContent(676,0.6800311);
     hrf->SetBinContent(677,0.665933);
     hrf->SetBinContent(678,0.6588035);
     hrf->SetBinContent(679,0.6570917);
     hrf->SetBinContent(680,0.6399373);
     hrf->SetBinContent(681,0.6336509);
     hrf->SetBinContent(682,0.6271339);
     hrf->SetBinContent(683,0.6279051);
     hrf->SetBinContent(684,0.6140663);
     hrf->SetBinContent(685,0.6070532);
     hrf->SetBinContent(686,0.6170091);
     hrf->SetBinContent(687,0.6174384);
     hrf->SetBinContent(688,0.6121793);
     hrf->SetBinContent(689,0.6064191);
     hrf->SetBinContent(690,0.6193621);
     hrf->SetBinContent(691,0.6625033);
     hrf->SetBinContent(692,0.7497195);
     hrf->SetBinContent(693,0.7461648);
     hrf->SetBinContent(694,0.7443557);
     hrf->SetBinContent(695,0.7535318);
     hrf->SetBinContent(696,0.7649554);
     hrf->SetBinContent(697,0.7840306);
     hrf->SetBinContent(698,0.7808634);
     hrf->SetBinContent(699,0.7844161);
     hrf->SetBinContent(700,0.7727049);
     hrf->SetBinContent(703,0.79143);
     hrf->SetBinContent(704,0.8175707);
     hrf->SetBinContent(705,0.8097944);
     hrf->SetBinContent(706,0.8196373);
     hrf->SetBinContent(707,0.8037912);
     hrf->SetBinContent(708,0.8060334);
     hrf->SetBinContent(709,0.7844828);
     hrf->SetBinContent(710,0.7781734);
     hrf->SetBinContent(711,0.7990621);
     hrf->SetBinContent(712,0.6977159);
     hrf->SetBinContent(713,0.6567251);
     hrf->SetBinContent(714,0.6458738);
     hrf->SetBinContent(715,0.6391681);
     hrf->SetBinContent(716,0.6486698);
     hrf->SetBinContent(717,0.6482897);
     hrf->SetBinContent(718,0.6564287);
     hrf->SetBinContent(719,0.647959);
     hrf->SetBinContent(720,0.6545083);
     hrf->SetBinContent(721,0.6605134);
     hrf->SetBinContent(722,0.654643);
     hrf->SetBinContent(723,0.6720995);
     hrf->SetBinContent(724,0.674703);
     hrf->SetBinContent(725,0.6736486);
     hrf->SetBinContent(726,0.6720003);
     hrf->SetBinContent(727,0.6716139);
     hrf->SetBinContent(728,0.6925032);
     hrf->SetBinContent(729,0.6797168);
     hrf->SetBinContent(730,0.6764894);
     hrf->SetBinContent(731,0.6712697);
     hrf->SetBinContent(732,0.6748146);
     hrf->SetBinContent(733,0.6764159);
     hrf->SetBinContent(734,0.6675547);
     hrf->SetBinContent(735,0.6499624);
     hrf->SetBinContent(736,0.6558874);
     hrf->SetBinContent(737,0.655924);
     hrf->SetBinContent(738,0.6442464);
     hrf->SetBinContent(739,0.6524487);
     hrf->SetBinContent(740,0.6406163);
     hrf->SetBinContent(741,0.6279376);
     hrf->SetBinContent(742,0.6354516);
     hrf->SetBinContent(743,0.631308);
     hrf->SetBinContent(744,0.6505761);
     hrf->SetBinContent(745,0.6879659);
     hrf->SetBinContent(746,0.7664913);
     hrf->SetBinContent(747,0.7509025);
     hrf->SetBinContent(748,0.7499993);
     hrf->SetBinContent(749,0.7594694);
     hrf->SetBinContent(750,0.7788361);
     hrf->SetBinContent(751,0.7906924);
     hrf->SetBinContent(752,0.7932374);
     hrf->SetBinContent(753,0.7901082);
     hrf->SetBinContent(754,0.7791761);
     hrf->SetBinContent(757,0.8110717);
     hrf->SetBinContent(758,0.8380142);
     hrf->SetBinContent(759,0.8261526);
     hrf->SetBinContent(760,0.8238212);
     hrf->SetBinContent(761,0.8191666);
     hrf->SetBinContent(762,0.8118178);
     hrf->SetBinContent(763,0.8026837);
     hrf->SetBinContent(764,0.7950587);
     hrf->SetBinContent(765,0.8015642);
     hrf->SetBinContent(766,0.7203518);
     hrf->SetBinContent(767,0.7126079);
     hrf->SetBinContent(768,0.6955605);
     hrf->SetBinContent(769,0.6856663);
     hrf->SetBinContent(770,0.6942785);
     hrf->SetBinContent(771,0.6787785);
     hrf->SetBinContent(772,0.6844447);
     hrf->SetBinContent(773,0.6898586);
     hrf->SetBinContent(774,0.700813);
     hrf->SetBinContent(775,0.7038191);
     hrf->SetBinContent(776,0.6954153);
     hrf->SetBinContent(777,0.706893);
     hrf->SetBinContent(778,0.707776);
     hrf->SetBinContent(779,0.710542);
     hrf->SetBinContent(780,0.6989855);
     hrf->SetBinContent(781,0.6987113);
     hrf->SetBinContent(782,0.7227745);
     hrf->SetBinContent(783,0.7161766);
     hrf->SetBinContent(784,0.6978431);
     hrf->SetBinContent(785,0.703478);
     hrf->SetBinContent(786,0.7087042);
     hrf->SetBinContent(787,0.7052461);
     hrf->SetBinContent(788,0.6980579);
     hrf->SetBinContent(789,0.7004423);
     hrf->SetBinContent(790,0.688938);
     hrf->SetBinContent(791,0.6870395);
     hrf->SetBinContent(792,0.6967018);
     hrf->SetBinContent(793,0.7004873);
     hrf->SetBinContent(794,0.6929513);
     hrf->SetBinContent(795,0.6701168);
     hrf->SetBinContent(796,0.6766522);
     hrf->SetBinContent(797,0.6715191);
     hrf->SetBinContent(798,0.6891941);
     hrf->SetBinContent(799,0.7155854);
     hrf->SetBinContent(800,0.8024459);
     hrf->SetBinContent(801,0.7730235);
     hrf->SetBinContent(802,0.7852777);
     hrf->SetBinContent(803,0.7864005);
     hrf->SetBinContent(804,0.8006655);
     hrf->SetBinContent(805,0.8060328);
     hrf->SetBinContent(806,0.8051929);
     hrf->SetBinContent(807,0.8088812);
     hrf->SetBinContent(808,0.8048784);
     hrf->SetBinContent(811,0.828478);
     hrf->SetBinContent(812,0.8300321);
     hrf->SetBinContent(813,0.8421991);
     hrf->SetBinContent(814,0.8365502);
     hrf->SetBinContent(815,0.8302338);
     hrf->SetBinContent(816,0.830529);
     hrf->SetBinContent(817,0.8107802);
     hrf->SetBinContent(818,0.8061959);
     hrf->SetBinContent(819,0.8248827);
     hrf->SetBinContent(820,0.7303534);
     hrf->SetBinContent(821,0.7015954);
     hrf->SetBinContent(822,0.6989409);
     hrf->SetBinContent(823,0.7031218);
     hrf->SetBinContent(824,0.7116248);
     hrf->SetBinContent(825,0.7116616);
     hrf->SetBinContent(826,0.7064694);
     hrf->SetBinContent(827,0.721562);
     hrf->SetBinContent(828,0.7237493);
     hrf->SetBinContent(829,0.7249997);
     hrf->SetBinContent(830,0.7241992);
     hrf->SetBinContent(831,0.7378653);
     hrf->SetBinContent(832,0.7348103);
     hrf->SetBinContent(833,0.7233974);
     hrf->SetBinContent(834,0.7464554);
     hrf->SetBinContent(835,0.7290223);
     hrf->SetBinContent(836,0.7406547);
     hrf->SetBinContent(837,0.7428466);
     hrf->SetBinContent(838,0.7317876);
     hrf->SetBinContent(839,0.7378644);
     hrf->SetBinContent(840,0.7383478);
     hrf->SetBinContent(841,0.7281325);
     hrf->SetBinContent(842,0.7139049);
     hrf->SetBinContent(843,0.7221135);
     hrf->SetBinContent(844,0.7124106);
     hrf->SetBinContent(845,0.7245829);
     hrf->SetBinContent(846,0.7148562);
     hrf->SetBinContent(847,0.7135551);
     hrf->SetBinContent(848,0.711857);
     hrf->SetBinContent(849,0.7122115);
     hrf->SetBinContent(850,0.6893438);
     hrf->SetBinContent(851,0.6891645);
     hrf->SetBinContent(852,0.6930996);
     hrf->SetBinContent(853,0.7186014);
     hrf->SetBinContent(854,0.8179576);
     hrf->SetBinContent(855,0.7949426);
     hrf->SetBinContent(856,0.7879985);
     hrf->SetBinContent(857,0.8009133);
     hrf->SetBinContent(858,0.7969646);
     hrf->SetBinContent(859,0.8221051);
     hrf->SetBinContent(860,0.8201365);
     hrf->SetBinContent(861,0.8227643);
     hrf->SetBinContent(862,0.8171785);
     hrf->SetBinContent(865,0.8372037);
     hrf->SetBinContent(866,0.8434036);
     hrf->SetBinContent(867,0.8394099);
     hrf->SetBinContent(868,0.85263);
     hrf->SetBinContent(869,0.8264552);
     hrf->SetBinContent(870,0.8431022);
     hrf->SetBinContent(871,0.8168057);
     hrf->SetBinContent(872,0.8267195);
     hrf->SetBinContent(873,0.8416439);
     hrf->SetBinContent(874,0.7480366);
     hrf->SetBinContent(875,0.7120796);
     hrf->SetBinContent(876,0.7131553);
     hrf->SetBinContent(877,0.7088758);
     hrf->SetBinContent(878,0.7136126);
     hrf->SetBinContent(879,0.7403855);
     hrf->SetBinContent(880,0.742373);
     hrf->SetBinContent(881,0.7468469);
     hrf->SetBinContent(882,0.7468605);
     hrf->SetBinContent(883,0.7480819);
     hrf->SetBinContent(884,0.7456565);
     hrf->SetBinContent(885,0.7563028);
     hrf->SetBinContent(886,0.7579337);
     hrf->SetBinContent(887,0.7524621);
     hrf->SetBinContent(888,0.7615474);
     hrf->SetBinContent(889,0.7591589);
     hrf->SetBinContent(890,0.7580302);
     hrf->SetBinContent(891,0.7588596);
     hrf->SetBinContent(892,0.7566364);
     hrf->SetBinContent(893,0.7544942);
     hrf->SetBinContent(894,0.7538131);
     hrf->SetBinContent(895,0.7591716);
     hrf->SetBinContent(896,0.7503425);
     hrf->SetBinContent(897,0.7677357);
     hrf->SetBinContent(898,0.7441401);
     hrf->SetBinContent(899,0.7495831);
     hrf->SetBinContent(900,0.7336878);
     hrf->SetBinContent(901,0.7278067);
     hrf->SetBinContent(902,0.7370681);
     hrf->SetBinContent(903,0.7159551);
     hrf->SetBinContent(904,0.7108493);
     hrf->SetBinContent(905,0.7052596);
     hrf->SetBinContent(906,0.70617);
     hrf->SetBinContent(907,0.7400752);
     hrf->SetBinContent(908,0.828081);
     hrf->SetBinContent(909,0.8022696);
     hrf->SetBinContent(910,0.7955783);
     hrf->SetBinContent(911,0.8050228);
     hrf->SetBinContent(912,0.8143564);
     hrf->SetBinContent(913,0.8210121);
     hrf->SetBinContent(914,0.8313174);
     hrf->SetBinContent(915,0.8341477);
     hrf->SetBinContent(916,0.8276628);
     hrf->SetBinContent(919,0.8357379);
     hrf->SetBinContent(920,0.8381479);
     hrf->SetBinContent(921,0.8444386);
     hrf->SetBinContent(922,0.8521889);
     hrf->SetBinContent(923,0.8359455);
     hrf->SetBinContent(924,0.8334427);
     hrf->SetBinContent(925,0.8269944);
     hrf->SetBinContent(926,0.8278334);
     hrf->SetBinContent(927,0.8484597);
     hrf->SetBinContent(928,0.7543424);
     hrf->SetBinContent(929,0.7237014);
     hrf->SetBinContent(930,0.7300712);
     hrf->SetBinContent(931,0.7255344);
     hrf->SetBinContent(932,0.7279992);
     hrf->SetBinContent(933,0.7446671);
     hrf->SetBinContent(934,0.757793);
     hrf->SetBinContent(935,0.7646086);
     hrf->SetBinContent(936,0.7726059);
     hrf->SetBinContent(937,0.7719304);
     hrf->SetBinContent(938,0.7673779);
     hrf->SetBinContent(939,0.7615338);
     hrf->SetBinContent(940,0.7828174);
     hrf->SetBinContent(941,0.7761256);
     hrf->SetBinContent(942,0.7770767);
     hrf->SetBinContent(943,0.7809832);
     hrf->SetBinContent(944,0.775672);
     hrf->SetBinContent(945,0.7823281);
     hrf->SetBinContent(946,0.7677814);
     hrf->SetBinContent(947,0.7777502);
     hrf->SetBinContent(948,0.7756031);
     hrf->SetBinContent(949,0.7791944);
     hrf->SetBinContent(950,0.7667066);
     hrf->SetBinContent(951,0.7644495);
     hrf->SetBinContent(952,0.7643178);
     hrf->SetBinContent(953,0.758558);
     hrf->SetBinContent(954,0.7542499);
     hrf->SetBinContent(955,0.7594551);
     hrf->SetBinContent(956,0.7431659);
     hrf->SetBinContent(957,0.7187039);
     hrf->SetBinContent(958,0.7167979);
     hrf->SetBinContent(959,0.7137383);
     hrf->SetBinContent(960,0.7135442);
     hrf->SetBinContent(961,0.7386492);
     hrf->SetBinContent(962,0.8410811);
     hrf->SetBinContent(963,0.8221065);
     hrf->SetBinContent(964,0.8045056);
     hrf->SetBinContent(965,0.8089661);
     hrf->SetBinContent(966,0.8274295);
     hrf->SetBinContent(967,0.8327056);
     hrf->SetBinContent(968,0.8339137);
     hrf->SetBinContent(969,0.8401244);
     hrf->SetBinContent(970,0.8328208);
     hrf->SetBinContent(973,0.8514778);
     hrf->SetBinContent(974,0.8586817);
     hrf->SetBinContent(975,0.8520512);
     hrf->SetBinContent(976,0.8530916);
     hrf->SetBinContent(977,0.8531001);
     hrf->SetBinContent(978,0.8351443);
     hrf->SetBinContent(979,0.8395857);
     hrf->SetBinContent(980,0.8349355);
     hrf->SetBinContent(981,0.8600548);
     hrf->SetBinContent(982,0.7740794);
     hrf->SetBinContent(983,0.7398908);
     hrf->SetBinContent(984,0.730821);
     hrf->SetBinContent(985,0.7287126);
     hrf->SetBinContent(986,0.7518275);
     hrf->SetBinContent(987,0.7515175);
     hrf->SetBinContent(988,0.7600703);
     hrf->SetBinContent(989,0.7720006);
     hrf->SetBinContent(990,0.7799897);
     hrf->SetBinContent(991,0.7874361);
     hrf->SetBinContent(992,0.8000161);
     hrf->SetBinContent(993,0.7943968);
     hrf->SetBinContent(994,0.7992765);
     hrf->SetBinContent(995,0.8026219);
     hrf->SetBinContent(996,0.8092993);
     hrf->SetBinContent(997,0.8061416);
     hrf->SetBinContent(998,0.7979919);
     hrf->SetBinContent(999,0.807699);
     hrf->SetBinContent(1000,0.8014735);
     hrf->SetBinContent(1001,0.7990585);
     hrf->SetBinContent(1002,0.800338);
     hrf->SetBinContent(1003,0.8032897);
     hrf->SetBinContent(1004,0.8062115);
     hrf->SetBinContent(1005,0.7816278);
     hrf->SetBinContent(1006,0.7867376);
     hrf->SetBinContent(1007,0.7911171);
     hrf->SetBinContent(1008,0.7713616);
     hrf->SetBinContent(1009,0.7612013);
     hrf->SetBinContent(1010,0.7483594);
     hrf->SetBinContent(1011,0.7335092);
     hrf->SetBinContent(1012,0.7379464);
     hrf->SetBinContent(1013,0.7298684);
     hrf->SetBinContent(1014,0.7319131);
     hrf->SetBinContent(1015,0.7636759);
     hrf->SetBinContent(1016,0.8397166);
     hrf->SetBinContent(1017,0.8313021);
     hrf->SetBinContent(1018,0.8312497);
     hrf->SetBinContent(1019,0.8293538);
     hrf->SetBinContent(1020,0.8377833);
     hrf->SetBinContent(1021,0.8391762);
     hrf->SetBinContent(1022,0.8472521);
     hrf->SetBinContent(1023,0.8437346);
     hrf->SetBinContent(1024,0.8413609);
     hrf->SetBinContent(1027,0.8706501);
     hrf->SetBinContent(1028,0.8708884);
     hrf->SetBinContent(1029,0.8596638);
     hrf->SetBinContent(1030,0.8669677);
     hrf->SetBinContent(1031,0.8618272);
     hrf->SetBinContent(1032,0.8499665);
     hrf->SetBinContent(1033,0.8595119);
     hrf->SetBinContent(1034,0.8574477);
     hrf->SetBinContent(1035,0.8665594);
     hrf->SetBinContent(1036,0.7836786);
     hrf->SetBinContent(1037,0.7570157);
     hrf->SetBinContent(1038,0.7496819);
     hrf->SetBinContent(1039,0.7568184);
     hrf->SetBinContent(1040,0.7622727);
     hrf->SetBinContent(1041,0.7782569);
     hrf->SetBinContent(1042,0.7813501);
     hrf->SetBinContent(1043,0.7854785);
     hrf->SetBinContent(1044,0.8024394);
     hrf->SetBinContent(1045,0.8006565);
     hrf->SetBinContent(1046,0.8093139);
     hrf->SetBinContent(1047,0.8140576);
     hrf->SetBinContent(1048,0.8294069);
     hrf->SetBinContent(1049,0.8265017);
     hrf->SetBinContent(1050,0.8219708);
     hrf->SetBinContent(1051,0.8306177);
     hrf->SetBinContent(1052,0.8356077);
     hrf->SetBinContent(1053,0.821778);
     hrf->SetBinContent(1054,0.8324773);
     hrf->SetBinContent(1055,0.8327084);
     hrf->SetBinContent(1056,0.8280543);
     hrf->SetBinContent(1057,0.8213516);
     hrf->SetBinContent(1058,0.8111429);
     hrf->SetBinContent(1059,0.8049538);
     hrf->SetBinContent(1060,0.7954642);
     hrf->SetBinContent(1061,0.7925411);
     hrf->SetBinContent(1062,0.7914885);
     hrf->SetBinContent(1063,0.7779347);
     hrf->SetBinContent(1064,0.7610781);
     hrf->SetBinContent(1065,0.7743629);
     hrf->SetBinContent(1066,0.7556941);
     hrf->SetBinContent(1067,0.740801);
     hrf->SetBinContent(1068,0.756769);
     hrf->SetBinContent(1069,0.7749262);
     hrf->SetBinContent(1070,0.8637108);
     hrf->SetBinContent(1071,0.8421297);
     hrf->SetBinContent(1072,0.8345889);
     hrf->SetBinContent(1073,0.8484675);
     hrf->SetBinContent(1074,0.8509088);
     hrf->SetBinContent(1075,0.8528676);
     hrf->SetBinContent(1076,0.8609979);
     hrf->SetBinContent(1077,0.863323);
     hrf->SetBinContent(1078,0.8613247);
     hrf->SetBinContent(1081,0.8834211);
     hrf->SetBinContent(1082,0.8786597);
     hrf->SetBinContent(1083,0.8725045);
     hrf->SetBinContent(1084,0.8704908);
     hrf->SetBinContent(1085,0.8642075);
     hrf->SetBinContent(1086,0.8703049);
     hrf->SetBinContent(1087,0.8612224);
     hrf->SetBinContent(1088,0.8590188);
     hrf->SetBinContent(1089,0.8811834);
     hrf->SetBinContent(1090,0.8036878);
     hrf->SetBinContent(1091,0.7733839);
     hrf->SetBinContent(1092,0.7577583);
     hrf->SetBinContent(1093,0.7661267);
     hrf->SetBinContent(1094,0.7779632);
     hrf->SetBinContent(1095,0.7867661);
     hrf->SetBinContent(1096,0.7944651);
     hrf->SetBinContent(1097,0.8083544);
     hrf->SetBinContent(1098,0.8107268);
     hrf->SetBinContent(1099,0.8189852);
     hrf->SetBinContent(1100,0.8153532);
     hrf->SetBinContent(1101,0.8240046);
     hrf->SetBinContent(1102,0.8384827);
     hrf->SetBinContent(1103,0.8322271);
     hrf->SetBinContent(1104,0.8422883);
     hrf->SetBinContent(1105,0.8423601);
     hrf->SetBinContent(1106,0.8466352);
     hrf->SetBinContent(1107,0.8430629);
     hrf->SetBinContent(1108,0.8358093);
     hrf->SetBinContent(1109,0.837386);
     hrf->SetBinContent(1110,0.8362738);
     hrf->SetBinContent(1111,0.8342865);
     hrf->SetBinContent(1112,0.8284599);
     hrf->SetBinContent(1113,0.8158783);
     hrf->SetBinContent(1114,0.8194523);
     hrf->SetBinContent(1115,0.8146015);
     hrf->SetBinContent(1116,0.8001814);
     hrf->SetBinContent(1117,0.8017688);
     hrf->SetBinContent(1118,0.7813054);
     hrf->SetBinContent(1119,0.7750396);
     hrf->SetBinContent(1120,0.758478);
     hrf->SetBinContent(1121,0.7584834);
     hrf->SetBinContent(1122,0.7688718);
     hrf->SetBinContent(1123,0.787861);
     hrf->SetBinContent(1124,0.8688133);
     hrf->SetBinContent(1125,0.8533958);
     hrf->SetBinContent(1126,0.8537074);
     hrf->SetBinContent(1127,0.8606731);
     hrf->SetBinContent(1128,0.8661022);
     hrf->SetBinContent(1129,0.8672564);
     hrf->SetBinContent(1130,0.8706612);
     hrf->SetBinContent(1131,0.8754287);
     hrf->SetBinContent(1132,0.8721613);
     hrf->SetBinContent(1135,0.8926414);
     hrf->SetBinContent(1136,0.8838556);
     hrf->SetBinContent(1137,0.8809255);
     hrf->SetBinContent(1138,0.8815078);
     hrf->SetBinContent(1139,0.8786798);
     hrf->SetBinContent(1140,0.8731456);
     hrf->SetBinContent(1141,0.8755729);
     hrf->SetBinContent(1142,0.8755569);
     hrf->SetBinContent(1143,0.8917107);
     hrf->SetBinContent(1144,0.8022393);
     hrf->SetBinContent(1145,0.7890468);
     hrf->SetBinContent(1146,0.7707567);
     hrf->SetBinContent(1147,0.7820282);
     hrf->SetBinContent(1148,0.797209);
     hrf->SetBinContent(1149,0.8015469);
     hrf->SetBinContent(1150,0.7989428);
     hrf->SetBinContent(1151,0.81494);
     hrf->SetBinContent(1152,0.8054802);
     hrf->SetBinContent(1153,0.8292938);
     hrf->SetBinContent(1154,0.8191403);
     hrf->SetBinContent(1155,0.8357392);
     hrf->SetBinContent(1156,0.8420494);
     hrf->SetBinContent(1157,0.8470226);
     hrf->SetBinContent(1158,0.8452826);
     hrf->SetBinContent(1159,0.8380713);
     hrf->SetBinContent(1160,0.8519661);
     hrf->SetBinContent(1161,0.8480266);
     hrf->SetBinContent(1162,0.8431207);
     hrf->SetBinContent(1163,0.8380831);
     hrf->SetBinContent(1164,0.8396802);
     hrf->SetBinContent(1165,0.8437529);
     hrf->SetBinContent(1166,0.8442971);
     hrf->SetBinContent(1167,0.8320925);
     hrf->SetBinContent(1168,0.8239457);
     hrf->SetBinContent(1169,0.8274932);
     hrf->SetBinContent(1170,0.8114532);
     hrf->SetBinContent(1171,0.7998323);
     hrf->SetBinContent(1172,0.7996237);
     hrf->SetBinContent(1173,0.792009);
     hrf->SetBinContent(1174,0.7787869);
     hrf->SetBinContent(1175,0.7690356);
     hrf->SetBinContent(1176,0.775647);
     hrf->SetBinContent(1177,0.814122);
     hrf->SetBinContent(1178,0.884719);
     hrf->SetBinContent(1179,0.8670786);
     hrf->SetBinContent(1180,0.8654112);
     hrf->SetBinContent(1181,0.8604522);
     hrf->SetBinContent(1182,0.8731483);
     hrf->SetBinContent(1183,0.8786311);
     hrf->SetBinContent(1184,0.8848958);
     hrf->SetBinContent(1185,0.8810438);
     hrf->SetBinContent(1186,0.8841771);
     hrf->SetBinContent(1189,0.8891022);
     hrf->SetBinContent(1190,0.8870587);
     hrf->SetBinContent(1191,0.8841472);
     hrf->SetBinContent(1192,0.8857799);
     hrf->SetBinContent(1193,0.8845335);
     hrf->SetBinContent(1194,0.8843443);
     hrf->SetBinContent(1195,0.8777463);
     hrf->SetBinContent(1196,0.880188);
     hrf->SetBinContent(1197,0.8909612);
     hrf->SetBinContent(1198,0.8178039);
     hrf->SetBinContent(1199,0.790151);
     hrf->SetBinContent(1200,0.7816035);
     hrf->SetBinContent(1201,0.7839964);
     hrf->SetBinContent(1202,0.7903005);
     hrf->SetBinContent(1203,0.8072708);
     hrf->SetBinContent(1204,0.8133928);
     hrf->SetBinContent(1205,0.8225427);
     hrf->SetBinContent(1206,0.833207);
     hrf->SetBinContent(1207,0.8298087);
     hrf->SetBinContent(1208,0.8389301);
     hrf->SetBinContent(1209,0.8460385);
     hrf->SetBinContent(1210,0.8437337);
     hrf->SetBinContent(1211,0.8557595);
     hrf->SetBinContent(1212,0.8491873);
     hrf->SetBinContent(1213,0.8516658);
     hrf->SetBinContent(1214,0.8624567);
     hrf->SetBinContent(1215,0.8594553);
     hrf->SetBinContent(1216,0.8509933);
     hrf->SetBinContent(1217,0.8471743);
     hrf->SetBinContent(1218,0.857959);
     hrf->SetBinContent(1219,0.8493754);
     hrf->SetBinContent(1220,0.8466064);
     hrf->SetBinContent(1221,0.8371781);
     hrf->SetBinContent(1222,0.8358744);
     hrf->SetBinContent(1223,0.8226563);
     hrf->SetBinContent(1224,0.8172606);
     hrf->SetBinContent(1225,0.8109908);
     hrf->SetBinContent(1226,0.806832);
     hrf->SetBinContent(1227,0.7952395);
     hrf->SetBinContent(1228,0.7979003);
     hrf->SetBinContent(1229,0.7853494);
     hrf->SetBinContent(1230,0.7877384);
     hrf->SetBinContent(1231,0.8165073);
     hrf->SetBinContent(1232,0.8852444);
     hrf->SetBinContent(1233,0.8795059);
     hrf->SetBinContent(1234,0.8737102);
     hrf->SetBinContent(1235,0.8798409);
     hrf->SetBinContent(1236,0.8834345);
     hrf->SetBinContent(1237,0.8831002);
     hrf->SetBinContent(1238,0.8838814);
     hrf->SetBinContent(1239,0.8873666);
     hrf->SetBinContent(1240,0.8796175);
     hrf->SetBinContent(1243,0.8699931);
     hrf->SetBinContent(1244,0.880556);
     hrf->SetBinContent(1245,0.8857679);
     hrf->SetBinContent(1246,0.8867575);
     hrf->SetBinContent(1247,0.8872436);
     hrf->SetBinContent(1248,0.8805988);
     hrf->SetBinContent(1249,0.8760417);
     hrf->SetBinContent(1250,0.8839202);
     hrf->SetBinContent(1251,0.8939078);
     hrf->SetBinContent(1252,0.8196212);
     hrf->SetBinContent(1253,0.7951305);
     hrf->SetBinContent(1254,0.7839375);
     hrf->SetBinContent(1255,0.7964276);
     hrf->SetBinContent(1256,0.8000515);
     hrf->SetBinContent(1257,0.8042353);
     hrf->SetBinContent(1258,0.8224838);
     hrf->SetBinContent(1259,0.8265044);
     hrf->SetBinContent(1260,0.842755);
     hrf->SetBinContent(1261,0.8381351);
     hrf->SetBinContent(1262,0.8499912);
     hrf->SetBinContent(1263,0.8451387);
     hrf->SetBinContent(1264,0.8538584);
     hrf->SetBinContent(1265,0.8548691);
     hrf->SetBinContent(1266,0.8640006);
     hrf->SetBinContent(1267,0.8592045);
     hrf->SetBinContent(1268,0.8652804);
     hrf->SetBinContent(1269,0.8636556);
     hrf->SetBinContent(1270,0.8597942);
     hrf->SetBinContent(1271,0.8495367);
     hrf->SetBinContent(1272,0.8544548);
     hrf->SetBinContent(1273,0.8598359);
     hrf->SetBinContent(1274,0.8494906);
     hrf->SetBinContent(1275,0.8489674);
     hrf->SetBinContent(1276,0.8405565);
     hrf->SetBinContent(1277,0.8359114);
     hrf->SetBinContent(1278,0.8236802);
     hrf->SetBinContent(1279,0.8239701);
     hrf->SetBinContent(1280,0.8109244);
     hrf->SetBinContent(1281,0.8064739);
     hrf->SetBinContent(1282,0.7994598);
     hrf->SetBinContent(1283,0.7857624);
     hrf->SetBinContent(1284,0.7976);
     hrf->SetBinContent(1285,0.817425);
     hrf->SetBinContent(1286,0.8980819);
     hrf->SetBinContent(1287,0.8794962);
     hrf->SetBinContent(1288,0.8744811);
     hrf->SetBinContent(1289,0.8777318);
     hrf->SetBinContent(1290,0.8769578);
     hrf->SetBinContent(1291,0.8837912);
     hrf->SetBinContent(1292,0.8830451);
     hrf->SetBinContent(1293,0.8832207);
     hrf->SetBinContent(1294,0.8726093);
     hrf->SetBinContent(1297,0.8833746);
     hrf->SetBinContent(1298,0.8892896);
     hrf->SetBinContent(1299,0.8946407);
     hrf->SetBinContent(1300,0.886827);
     hrf->SetBinContent(1301,0.8873971);
     hrf->SetBinContent(1302,0.8878529);
     hrf->SetBinContent(1303,0.8882861);
     hrf->SetBinContent(1304,0.8945645);
     hrf->SetBinContent(1305,0.9100397);
     hrf->SetBinContent(1306,0.8372028);
     hrf->SetBinContent(1307,0.8102537);
     hrf->SetBinContent(1308,0.8034006);
     hrf->SetBinContent(1309,0.8103142);
     hrf->SetBinContent(1310,0.809669);
     hrf->SetBinContent(1311,0.8221305);
     hrf->SetBinContent(1312,0.8360682);
     hrf->SetBinContent(1313,0.8428956);
     hrf->SetBinContent(1314,0.8529904);
     hrf->SetBinContent(1315,0.8403449);
     hrf->SetBinContent(1316,0.847197);
     hrf->SetBinContent(1317,0.8571557);
     hrf->SetBinContent(1318,0.8633579);
     hrf->SetBinContent(1319,0.8623986);
     hrf->SetBinContent(1320,0.8692189);
     hrf->SetBinContent(1321,0.8681874);
     hrf->SetBinContent(1322,0.8733714);
     hrf->SetBinContent(1323,0.8649191);
     hrf->SetBinContent(1324,0.8690168);
     hrf->SetBinContent(1325,0.8687195);
     hrf->SetBinContent(1326,0.8682766);
     hrf->SetBinContent(1327,0.8630986);
     hrf->SetBinContent(1328,0.8554676);
     hrf->SetBinContent(1329,0.8457834);
     hrf->SetBinContent(1330,0.8468786);
     hrf->SetBinContent(1331,0.8466587);
     hrf->SetBinContent(1332,0.8327401);
     hrf->SetBinContent(1333,0.8289707);
     hrf->SetBinContent(1334,0.8209063);
     hrf->SetBinContent(1335,0.8148324);
     hrf->SetBinContent(1336,0.8016603);
     hrf->SetBinContent(1337,0.8032823);
     hrf->SetBinContent(1338,0.8121458);
     hrf->SetBinContent(1339,0.8311667);
     hrf->SetBinContent(1340,0.9000667);
     hrf->SetBinContent(1341,0.8870225);
     hrf->SetBinContent(1342,0.8807783);
     hrf->SetBinContent(1343,0.8867585);
     hrf->SetBinContent(1344,0.887088);
     hrf->SetBinContent(1345,0.8945184);
     hrf->SetBinContent(1346,0.8915095);
     hrf->SetBinContent(1347,0.8958459);
     hrf->SetBinContent(1348,0.8770605);
     hrf->SetBinContent(1351,0.9107674);
     hrf->SetBinContent(1352,0.901845);
     hrf->SetBinContent(1353,0.9046344);
     hrf->SetBinContent(1354,0.9028492);
     hrf->SetBinContent(1355,0.9029417);
     hrf->SetBinContent(1356,0.9025894);
     hrf->SetBinContent(1357,0.9009511);
     hrf->SetBinContent(1358,0.9044149);
     hrf->SetBinContent(1359,0.9154013);
     hrf->SetBinContent(1360,0.8367298);
     hrf->SetBinContent(1361,0.8242673);
     hrf->SetBinContent(1362,0.8122698);
     hrf->SetBinContent(1363,0.8129655);
     hrf->SetBinContent(1364,0.8246857);
     hrf->SetBinContent(1365,0.8306041);
     hrf->SetBinContent(1366,0.8359771);
     hrf->SetBinContent(1367,0.8536226);
     hrf->SetBinContent(1368,0.8658685);
     hrf->SetBinContent(1369,0.866558);
     hrf->SetBinContent(1370,0.8651952);
     hrf->SetBinContent(1371,0.8684635);
     hrf->SetBinContent(1372,0.8754547);
     hrf->SetBinContent(1373,0.8689093);
     hrf->SetBinContent(1374,0.8794907);
     hrf->SetBinContent(1375,0.8772472);
     hrf->SetBinContent(1376,0.8768589);
     hrf->SetBinContent(1377,0.8863833);
     hrf->SetBinContent(1378,0.8752023);
     hrf->SetBinContent(1379,0.8694621);
     hrf->SetBinContent(1380,0.8833391);
     hrf->SetBinContent(1381,0.8768603);
     hrf->SetBinContent(1382,0.869158);
     hrf->SetBinContent(1383,0.8667737);
     hrf->SetBinContent(1384,0.8611507);
     hrf->SetBinContent(1385,0.8608423);
     hrf->SetBinContent(1386,0.8516886);
     hrf->SetBinContent(1387,0.8415661);
     hrf->SetBinContent(1388,0.8409142);
     hrf->SetBinContent(1389,0.8235896);
     hrf->SetBinContent(1390,0.8184434);
     hrf->SetBinContent(1391,0.8097028);
     hrf->SetBinContent(1392,0.8229869);
     hrf->SetBinContent(1393,0.8520653);
     hrf->SetBinContent(1394,0.91498);
     hrf->SetBinContent(1395,0.9005948);
     hrf->SetBinContent(1396,0.8929456);
     hrf->SetBinContent(1397,0.8981298);
     hrf->SetBinContent(1398,0.903121);
     hrf->SetBinContent(1399,0.9075835);
     hrf->SetBinContent(1400,0.9140153);
     hrf->SetBinContent(1401,0.9101715);
     hrf->SetBinContent(1402,0.911872);
     hrf->SetBinContent(1405,0.9039399);
     hrf->SetBinContent(1406,0.9063057);
     hrf->SetBinContent(1407,0.9046811);
     hrf->SetBinContent(1408,0.9110272);
     hrf->SetBinContent(1409,0.9117368);
     hrf->SetBinContent(1410,0.9076403);
     hrf->SetBinContent(1411,0.9033728);
     hrf->SetBinContent(1412,0.908191);
     hrf->SetBinContent(1413,0.9208092);
     hrf->SetBinContent(1414,0.8550934);
     hrf->SetBinContent(1415,0.8329291);
     hrf->SetBinContent(1416,0.8214185);
     hrf->SetBinContent(1417,0.8256217);
     hrf->SetBinContent(1418,0.8495316);
     hrf->SetBinContent(1419,0.8494883);
     hrf->SetBinContent(1420,0.8567852);
     hrf->SetBinContent(1421,0.8572022);
     hrf->SetBinContent(1422,0.8683975);
     hrf->SetBinContent(1423,0.8678761);
     hrf->SetBinContent(1424,0.8731164);
     hrf->SetBinContent(1425,0.8683652);
     hrf->SetBinContent(1426,0.8794419);
     hrf->SetBinContent(1427,0.8815932);
     hrf->SetBinContent(1428,0.8864079);
     hrf->SetBinContent(1429,0.8836783);
     hrf->SetBinContent(1430,0.8894901);
     hrf->SetBinContent(1431,0.8901763);
     hrf->SetBinContent(1432,0.8808558);
     hrf->SetBinContent(1433,0.8784434);
     hrf->SetBinContent(1434,0.8785816);
     hrf->SetBinContent(1435,0.8881973);
     hrf->SetBinContent(1436,0.8753826);
     hrf->SetBinContent(1437,0.8633127);
     hrf->SetBinContent(1438,0.8630874);
     hrf->SetBinContent(1439,0.8581874);
     hrf->SetBinContent(1440,0.8548054);
     hrf->SetBinContent(1441,0.8631837);
     hrf->SetBinContent(1442,0.8439391);
     hrf->SetBinContent(1443,0.83869);
     hrf->SetBinContent(1444,0.8351945);
     hrf->SetBinContent(1445,0.8259542);
     hrf->SetBinContent(1446,0.8348157);
     hrf->SetBinContent(1447,0.8657665);
     hrf->SetBinContent(1448,0.919937);
     hrf->SetBinContent(1449,0.9106402);
     hrf->SetBinContent(1450,0.9066347);
     hrf->SetBinContent(1451,0.9057992);
     hrf->SetBinContent(1452,0.9104689);
     hrf->SetBinContent(1453,0.9105675);
     hrf->SetBinContent(1454,0.917769);
     hrf->SetBinContent(1455,0.9100168);
     hrf->SetBinContent(1456,0.9122199);
     hrf->SetBinContent(1459,0.8731261);
     hrf->SetBinContent(1460,0.8929094);
     hrf->SetBinContent(1461,0.9041327);
     hrf->SetBinContent(1462,0.9131415);
     hrf->SetBinContent(1463,0.9066501);
     hrf->SetBinContent(1464,0.907663);
     hrf->SetBinContent(1465,0.9030681);
     hrf->SetBinContent(1466,0.9116143);
     hrf->SetBinContent(1467,0.924934);
     hrf->SetBinContent(1468,0.8582804);
     hrf->SetBinContent(1469,0.8448771);
     hrf->SetBinContent(1470,0.8322512);
     hrf->SetBinContent(1471,0.8413401);
     hrf->SetBinContent(1472,0.8452342);
     hrf->SetBinContent(1473,0.8499962);
     hrf->SetBinContent(1474,0.8578755);
     hrf->SetBinContent(1475,0.870818);
     hrf->SetBinContent(1476,0.8684161);
     hrf->SetBinContent(1477,0.8717569);
     hrf->SetBinContent(1478,0.8661126);
     hrf->SetBinContent(1479,0.8748658);
     hrf->SetBinContent(1480,0.8945366);
     hrf->SetBinContent(1481,0.887479);
     hrf->SetBinContent(1482,0.8910479);
     hrf->SetBinContent(1483,0.8878255);
     hrf->SetBinContent(1484,0.8889695);
     hrf->SetBinContent(1485,0.8869578);
     hrf->SetBinContent(1486,0.8927147);
     hrf->SetBinContent(1487,0.893798);
     hrf->SetBinContent(1488,0.889362);
     hrf->SetBinContent(1489,0.8875631);
     hrf->SetBinContent(1490,0.890229);
     hrf->SetBinContent(1491,0.8816059);
     hrf->SetBinContent(1492,0.8668377);
     hrf->SetBinContent(1493,0.869731);
     hrf->SetBinContent(1494,0.8621845);
     hrf->SetBinContent(1495,0.8679706);
     hrf->SetBinContent(1496,0.8502749);
     hrf->SetBinContent(1497,0.8427823);
     hrf->SetBinContent(1498,0.8440582);
     hrf->SetBinContent(1499,0.8246489);
     hrf->SetBinContent(1500,0.838813);
     hrf->SetBinContent(1501,0.8574219);
     hrf->SetBinContent(1502,0.9263051);
     hrf->SetBinContent(1503,0.9140279);
     hrf->SetBinContent(1504,0.9136851);
     hrf->SetBinContent(1505,0.9010017);
     hrf->SetBinContent(1506,0.9108002);
     hrf->SetBinContent(1507,0.9104546);
     hrf->SetBinContent(1508,0.9128228);
     hrf->SetBinContent(1509,0.8955492);
     hrf->SetBinContent(1510,0.895875);
     hrf->SetBinContent(1513,0.8521476);
     hrf->SetBinContent(1514,0.8678765);
     hrf->SetBinContent(1515,0.8819187);
     hrf->SetBinContent(1516,0.8971331);
     hrf->SetBinContent(1517,0.8997292);
     hrf->SetBinContent(1518,0.9004843);
     hrf->SetBinContent(1519,0.9072738);
     hrf->SetBinContent(1520,0.9154096);
     hrf->SetBinContent(1521,0.9255536);
     hrf->SetBinContent(1522,0.8642027);
     hrf->SetBinContent(1523,0.8448632);
     hrf->SetBinContent(1524,0.8316462);
     hrf->SetBinContent(1525,0.8349957);
     hrf->SetBinContent(1526,0.8407539);
     hrf->SetBinContent(1527,0.850341);
     hrf->SetBinContent(1528,0.8542346);
     hrf->SetBinContent(1529,0.8641542);
     hrf->SetBinContent(1530,0.8824866);
     hrf->SetBinContent(1531,0.875233);
     hrf->SetBinContent(1532,0.8747888);
     hrf->SetBinContent(1533,0.8876879);
     hrf->SetBinContent(1534,0.8921785);
     hrf->SetBinContent(1535,0.8959677);
     hrf->SetBinContent(1536,0.8927501);
     hrf->SetBinContent(1537,0.8898901);
     hrf->SetBinContent(1538,0.8942666);
     hrf->SetBinContent(1539,0.892297);
     hrf->SetBinContent(1540,0.8892371);
     hrf->SetBinContent(1541,0.892962);
     hrf->SetBinContent(1542,0.8810925);
     hrf->SetBinContent(1543,0.8918186);
     hrf->SetBinContent(1544,0.8845227);
     hrf->SetBinContent(1545,0.8848883);
     hrf->SetBinContent(1546,0.8825886);
     hrf->SetBinContent(1547,0.8737018);
     hrf->SetBinContent(1548,0.8694548);
     hrf->SetBinContent(1549,0.8615527);
     hrf->SetBinContent(1550,0.8557075);
     hrf->SetBinContent(1551,0.8527821);
     hrf->SetBinContent(1552,0.8239888);
     hrf->SetBinContent(1553,0.8215376);
     hrf->SetBinContent(1554,0.8346367);
     hrf->SetBinContent(1555,0.8683265);
     hrf->SetBinContent(1556,0.9221479);
     hrf->SetBinContent(1557,0.9117818);
     hrf->SetBinContent(1558,0.9093716);
     hrf->SetBinContent(1559,0.9003564);
     hrf->SetBinContent(1560,0.8994485);
     hrf->SetBinContent(1561,0.8900582);
     hrf->SetBinContent(1562,0.8851296);
     hrf->SetBinContent(1563,0.8711704);
     hrf->SetBinContent(1564,0.8568475);
  
     return hrf;
  }

  // ------------ single pion response function from mode ------------
  TH2D* MuonTCMETValueMapProducer::getResponseFunction_mode() {
  
    Double_t xAxis2[53] = {-2.5, -2.322, -2.172, -2.043, 
                           -1.93, -1.83, -1.74, -1.653, 
                           -1.566, -1.479, -1.392, -1.305, 
                           -1.218, -1.131, -1.044, -0.957, 
                           -0.879, -0.783, -0.696, -0.609, 
                           -0.522, -0.435, -0.348, -0.261, 
                           -0.174, -0.087, 0, 0.087, 0.174, 
                           0.261, 0.348, 0.435, 0.522, 0.609, 
                           0.696, 0.783, 0.879, 0.957, 1.044, 
                           1.131, 1.218, 1.305, 1.392, 1.479, 
                           1.566, 1.653, 1.74, 1.83, 1.93, 
                           2.043, 2.172, 2.322, 2.5}; 
  
    Double_t yAxis2[29] = {0, 0.5, 1, 1.5, 2, 3, 4, 5, 6, 7, 
                           8, 9, 10, 12, 14, 16, 18, 20, 25, 
                           30, 35, 40, 45, 50, 60, 70, 80, 90, 100}; 
   
    TH2D *hrf = new TH2D("hrf","RF  (mode)",52, xAxis2,28, yAxis2);

    hrf->SetBinContent(163,0.5);
    hrf->SetBinContent(164,0.58);
    hrf->SetBinContent(165,0.62);
    hrf->SetBinContent(166,0.54);
    hrf->SetBinContent(167,0.46);
    hrf->SetBinContent(168,0.14);
    hrf->SetBinContent(169,0.14);
    hrf->SetBinContent(170,0.02);
    hrf->SetBinContent(171,0.02);
    hrf->SetBinContent(172,0.02);
    hrf->SetBinContent(173,0.02);
    hrf->SetBinContent(174,0.02);
    hrf->SetBinContent(175,0.02);
    hrf->SetBinContent(176,0.02);
    hrf->SetBinContent(177,0.02);
    hrf->SetBinContent(178,0.02);
    hrf->SetBinContent(179,0.02);
    hrf->SetBinContent(180,0.02);
    hrf->SetBinContent(181,0.02);
    hrf->SetBinContent(182,0.02);
    hrf->SetBinContent(183,0.02);
    hrf->SetBinContent(184,0.02);
    hrf->SetBinContent(185,0.02);
    hrf->SetBinContent(186,0.02);
    hrf->SetBinContent(187,0.02);
    hrf->SetBinContent(188,0.02);
    hrf->SetBinContent(189,0.02);
    hrf->SetBinContent(190,0.02);
    hrf->SetBinContent(191,0.02);
    hrf->SetBinContent(192,0.02);
    hrf->SetBinContent(193,0.02);
    hrf->SetBinContent(194,0.02);
    hrf->SetBinContent(195,0.02);
    hrf->SetBinContent(196,0.02);
    hrf->SetBinContent(197,0.02);
    hrf->SetBinContent(198,0.02);
    hrf->SetBinContent(199,0.02);
    hrf->SetBinContent(200,0.02);
    hrf->SetBinContent(201,0.02);
    hrf->SetBinContent(202,0.02);
    hrf->SetBinContent(203,0.02);
    hrf->SetBinContent(204,0.02);
    hrf->SetBinContent(205,0.02);
    hrf->SetBinContent(206,0.02);
    hrf->SetBinContent(207,0.02);
    hrf->SetBinContent(208,0.02);
    hrf->SetBinContent(209,0.02);
    hrf->SetBinContent(210,0.14);
    hrf->SetBinContent(211,0.1);
    hrf->SetBinContent(212,0.34);
    hrf->SetBinContent(213,0.34);
    hrf->SetBinContent(214,0.38);
    hrf->SetBinContent(217,0.5);
    hrf->SetBinContent(218,0.54);
    hrf->SetBinContent(219,0.5);
    hrf->SetBinContent(220,0.58);
    hrf->SetBinContent(221,0.46);
    hrf->SetBinContent(222,0.5);
    hrf->SetBinContent(223,0.1);
    hrf->SetBinContent(224,0.22);
    hrf->SetBinContent(225,0.02);
    hrf->SetBinContent(226,0.02);
    hrf->SetBinContent(227,0.02);
    hrf->SetBinContent(228,0.02);
    hrf->SetBinContent(229,0.02);
    hrf->SetBinContent(230,0.02);
    hrf->SetBinContent(231,0.02);
    hrf->SetBinContent(232,0.02);
    hrf->SetBinContent(233,0.02);
    hrf->SetBinContent(234,0.02);
    hrf->SetBinContent(235,0.02);
    hrf->SetBinContent(236,0.02);
    hrf->SetBinContent(237,0.02);
    hrf->SetBinContent(238,0.02);
    hrf->SetBinContent(239,0.02);
    hrf->SetBinContent(240,0.02);
    hrf->SetBinContent(241,0.02);
    hrf->SetBinContent(242,0.02);
    hrf->SetBinContent(243,0.02);
    hrf->SetBinContent(244,0.02);
    hrf->SetBinContent(245,0.02);
    hrf->SetBinContent(246,0.02);
    hrf->SetBinContent(247,0.02);
    hrf->SetBinContent(248,0.02);
    hrf->SetBinContent(249,0.02);
    hrf->SetBinContent(250,0.02);
    hrf->SetBinContent(251,0.02);
    hrf->SetBinContent(252,0.02);
    hrf->SetBinContent(253,0.02);
    hrf->SetBinContent(254,0.02);
    hrf->SetBinContent(255,0.02);
    hrf->SetBinContent(256,0.02);
    hrf->SetBinContent(257,0.02);
    hrf->SetBinContent(258,0.02);
    hrf->SetBinContent(259,0.02);
    hrf->SetBinContent(260,0.02);
    hrf->SetBinContent(261,0.02);
    hrf->SetBinContent(262,0.1);
    hrf->SetBinContent(263,0.1);
    hrf->SetBinContent(264,0.18);
    hrf->SetBinContent(265,0.38);
    hrf->SetBinContent(266,0.38);
    hrf->SetBinContent(267,0.42);
    hrf->SetBinContent(268,0.38);
    hrf->SetBinContent(271,0.5);
    hrf->SetBinContent(272,0.58);
    hrf->SetBinContent(273,0.58);
    hrf->SetBinContent(274,0.58);
    hrf->SetBinContent(275,0.42);
    hrf->SetBinContent(276,0.42);
    hrf->SetBinContent(277,0.38);
    hrf->SetBinContent(278,0.38);
    hrf->SetBinContent(279,0.18);
    hrf->SetBinContent(280,0.38);
    hrf->SetBinContent(281,0.38);
    hrf->SetBinContent(282,0.3);
    hrf->SetBinContent(283,0.3);
    hrf->SetBinContent(284,0.06);
    hrf->SetBinContent(285,0.06);
    hrf->SetBinContent(286,0.02);
    hrf->SetBinContent(287,0.02);
    hrf->SetBinContent(288,0.3);
    hrf->SetBinContent(289,0.02);
    hrf->SetBinContent(290,0.02);
    hrf->SetBinContent(291,0.02);
    hrf->SetBinContent(292,0.02);
    hrf->SetBinContent(293,0.02);
    hrf->SetBinContent(294,0.02);
    hrf->SetBinContent(295,0.02);
    hrf->SetBinContent(296,0.02);
    hrf->SetBinContent(297,0.02);
    hrf->SetBinContent(298,0.02);
    hrf->SetBinContent(299,0.02);
    hrf->SetBinContent(300,0.02);
    hrf->SetBinContent(301,0.02);
    hrf->SetBinContent(302,0.02);
    hrf->SetBinContent(303,0.02);
    hrf->SetBinContent(304,0.02);
    hrf->SetBinContent(305,0.02);
    hrf->SetBinContent(306,0.02);
    hrf->SetBinContent(307,0.02);
    hrf->SetBinContent(308,0.02);
    hrf->SetBinContent(309,0.02);
    hrf->SetBinContent(310,0.02);
    hrf->SetBinContent(311,0.3);
    hrf->SetBinContent(312,0.06);
    hrf->SetBinContent(313,0.02);
    hrf->SetBinContent(314,0.02);
    hrf->SetBinContent(315,0.3);
    hrf->SetBinContent(316,0.18);
    hrf->SetBinContent(317,0.26);
    hrf->SetBinContent(318,0.22);
    hrf->SetBinContent(319,0.34);
    hrf->SetBinContent(320,0.38);
    hrf->SetBinContent(321,0.5);
    hrf->SetBinContent(322,0.38);
    hrf->SetBinContent(325,0.66);
    hrf->SetBinContent(326,0.54);
    hrf->SetBinContent(327,0.58);
    hrf->SetBinContent(328,0.5);
    hrf->SetBinContent(329,0.38);
    hrf->SetBinContent(330,0.58);
    hrf->SetBinContent(331,0.42);
    hrf->SetBinContent(332,0.38);
    hrf->SetBinContent(333,0.38);
    hrf->SetBinContent(334,0.3);
    hrf->SetBinContent(335,0.3);
    hrf->SetBinContent(336,0.38);
    hrf->SetBinContent(337,0.3);
    hrf->SetBinContent(338,0.3);
    hrf->SetBinContent(339,0.34);
    hrf->SetBinContent(340,0.3);
    hrf->SetBinContent(341,0.26);
    hrf->SetBinContent(342,0.3);
    hrf->SetBinContent(343,0.34);
    hrf->SetBinContent(344,0.34);
    hrf->SetBinContent(345,0.34);
    hrf->SetBinContent(346,0.3);
    hrf->SetBinContent(347,0.46);
    hrf->SetBinContent(348,0.34);
    hrf->SetBinContent(349,0.38);
    hrf->SetBinContent(350,0.38);
    hrf->SetBinContent(351,0.3);
    hrf->SetBinContent(352,0.34);
    hrf->SetBinContent(353,0.34);
    hrf->SetBinContent(354,0.34);
    hrf->SetBinContent(355,0.38);
    hrf->SetBinContent(356,0.3);
    hrf->SetBinContent(357,0.3);
    hrf->SetBinContent(358,0.34);
    hrf->SetBinContent(359,0.34);
    hrf->SetBinContent(360,0.34);
    hrf->SetBinContent(361,0.34);
    hrf->SetBinContent(362,0.26);
    hrf->SetBinContent(363,0.38);
    hrf->SetBinContent(364,0.3);
    hrf->SetBinContent(365,0.3);
    hrf->SetBinContent(366,0.26);
    hrf->SetBinContent(367,0.3);
    hrf->SetBinContent(368,0.26);
    hrf->SetBinContent(369,0.3);
    hrf->SetBinContent(370,0.34);
    hrf->SetBinContent(371,0.5);
    hrf->SetBinContent(372,0.46);
    hrf->SetBinContent(373,0.46);
    hrf->SetBinContent(374,0.42);
    hrf->SetBinContent(375,0.54);
    hrf->SetBinContent(376,0.5);
    hrf->SetBinContent(379,0.74);
    hrf->SetBinContent(380,0.66);
    hrf->SetBinContent(381,0.74);
    hrf->SetBinContent(382,0.62);
    hrf->SetBinContent(383,0.54);
    hrf->SetBinContent(384,0.46);
    hrf->SetBinContent(385,0.46);
    hrf->SetBinContent(386,0.38);
    hrf->SetBinContent(387,0.34);
    hrf->SetBinContent(388,0.42);
    hrf->SetBinContent(389,0.46);
    hrf->SetBinContent(390,0.38);
    hrf->SetBinContent(391,0.42);
    hrf->SetBinContent(392,0.34);
    hrf->SetBinContent(393,0.42);
    hrf->SetBinContent(394,0.46);
    hrf->SetBinContent(395,0.38);
    hrf->SetBinContent(396,0.38);
    hrf->SetBinContent(397,0.5);
    hrf->SetBinContent(398,0.38);
    hrf->SetBinContent(399,0.42);
    hrf->SetBinContent(400,0.5);
    hrf->SetBinContent(401,0.38);
    hrf->SetBinContent(402,0.46);
    hrf->SetBinContent(403,0.42);
    hrf->SetBinContent(404,0.46);
    hrf->SetBinContent(405,0.38);
    hrf->SetBinContent(406,0.42);
    hrf->SetBinContent(407,0.46);
    hrf->SetBinContent(408,0.46);
    hrf->SetBinContent(409,0.46);
    hrf->SetBinContent(410,0.34);
    hrf->SetBinContent(411,0.46);
    hrf->SetBinContent(412,0.46);
    hrf->SetBinContent(413,0.46);
    hrf->SetBinContent(414,0.46);
    hrf->SetBinContent(415,0.34);
    hrf->SetBinContent(416,0.46);
    hrf->SetBinContent(417,0.42);
    hrf->SetBinContent(418,0.3);
    hrf->SetBinContent(419,0.46);
    hrf->SetBinContent(420,0.42);
    hrf->SetBinContent(421,0.38);
    hrf->SetBinContent(422,0.38);
    hrf->SetBinContent(423,0.5);
    hrf->SetBinContent(424,0.38);
    hrf->SetBinContent(425,0.46);
    hrf->SetBinContent(426,0.5);
    hrf->SetBinContent(427,0.58);
    hrf->SetBinContent(428,0.5);
    hrf->SetBinContent(429,0.54);
    hrf->SetBinContent(430,0.62);
    hrf->SetBinContent(433,0.74);
    hrf->SetBinContent(434,0.74);
    hrf->SetBinContent(435,0.74);
    hrf->SetBinContent(436,0.66);
    hrf->SetBinContent(437,0.58);
    hrf->SetBinContent(438,0.62);
    hrf->SetBinContent(439,0.54);
    hrf->SetBinContent(440,0.54);
    hrf->SetBinContent(441,0.46);
    hrf->SetBinContent(442,0.42);
    hrf->SetBinContent(443,0.46);
    hrf->SetBinContent(444,0.46);
    hrf->SetBinContent(445,0.34);
    hrf->SetBinContent(446,0.42);
    hrf->SetBinContent(447,0.38);
    hrf->SetBinContent(448,0.46);
    hrf->SetBinContent(449,0.38);
    hrf->SetBinContent(450,0.38);
    hrf->SetBinContent(451,0.5);
    hrf->SetBinContent(452,0.42);
    hrf->SetBinContent(453,0.46);
    hrf->SetBinContent(454,0.54);
    hrf->SetBinContent(455,0.5);
    hrf->SetBinContent(456,0.54);
    hrf->SetBinContent(457,0.46);
    hrf->SetBinContent(458,0.5);
    hrf->SetBinContent(459,0.46);
    hrf->SetBinContent(460,0.5);
    hrf->SetBinContent(461,0.42);
    hrf->SetBinContent(462,0.46);
    hrf->SetBinContent(463,0.5);
    hrf->SetBinContent(464,0.42);
    hrf->SetBinContent(465,0.42);
    hrf->SetBinContent(466,0.42);
    hrf->SetBinContent(467,0.46);
    hrf->SetBinContent(468,0.38);
    hrf->SetBinContent(469,0.5);
    hrf->SetBinContent(470,0.38);
    hrf->SetBinContent(471,0.46);
    hrf->SetBinContent(472,0.42);
    hrf->SetBinContent(473,0.46);
    hrf->SetBinContent(474,0.46);
    hrf->SetBinContent(475,0.34);
    hrf->SetBinContent(476,0.34);
    hrf->SetBinContent(477,0.5);
    hrf->SetBinContent(478,0.42);
    hrf->SetBinContent(479,0.5);
    hrf->SetBinContent(480,0.54);
    hrf->SetBinContent(481,0.62);
    hrf->SetBinContent(482,0.58);
    hrf->SetBinContent(483,0.66);
    hrf->SetBinContent(484,0.74);
    hrf->SetBinContent(487,0.82);
    hrf->SetBinContent(488,0.7);
    hrf->SetBinContent(489,0.66);
    hrf->SetBinContent(490,0.74);
    hrf->SetBinContent(491,0.7);
    hrf->SetBinContent(492,0.62);
    hrf->SetBinContent(493,0.62);
    hrf->SetBinContent(494,0.5);
    hrf->SetBinContent(495,0.46);
    hrf->SetBinContent(496,0.5);
    hrf->SetBinContent(497,0.5);
    hrf->SetBinContent(498,0.46);
    hrf->SetBinContent(499,0.5);
    hrf->SetBinContent(500,0.5);
    hrf->SetBinContent(501,0.42);
    hrf->SetBinContent(502,0.38);
    hrf->SetBinContent(503,0.42);
    hrf->SetBinContent(504,0.5);
    hrf->SetBinContent(505,0.5);
    hrf->SetBinContent(506,0.42);
    hrf->SetBinContent(507,0.5);
    hrf->SetBinContent(508,0.38);
    hrf->SetBinContent(509,0.54);
    hrf->SetBinContent(510,0.46);
    hrf->SetBinContent(511,0.54);
    hrf->SetBinContent(512,0.42);
    hrf->SetBinContent(513,0.5);
    hrf->SetBinContent(514,0.46);
    hrf->SetBinContent(515,0.42);
    hrf->SetBinContent(516,0.5);
    hrf->SetBinContent(517,0.46);
    hrf->SetBinContent(518,0.42);
    hrf->SetBinContent(519,0.42);
    hrf->SetBinContent(520,0.54);
    hrf->SetBinContent(521,0.42);
    hrf->SetBinContent(522,0.5);
    hrf->SetBinContent(523,0.46);
    hrf->SetBinContent(524,0.46);
    hrf->SetBinContent(525,0.38);
    hrf->SetBinContent(526,0.5);
    hrf->SetBinContent(527,0.5);
    hrf->SetBinContent(528,0.38);
    hrf->SetBinContent(529,0.46);
    hrf->SetBinContent(530,0.5);
    hrf->SetBinContent(531,0.42);
    hrf->SetBinContent(532,0.5);
    hrf->SetBinContent(533,0.58);
    hrf->SetBinContent(534,0.58);
    hrf->SetBinContent(535,0.66);
    hrf->SetBinContent(536,0.7);
    hrf->SetBinContent(537,0.66);
    hrf->SetBinContent(538,0.7);
    hrf->SetBinContent(541,0.74);
    hrf->SetBinContent(542,0.74);
    hrf->SetBinContent(543,0.74);
    hrf->SetBinContent(544,0.66);
    hrf->SetBinContent(545,0.74);
    hrf->SetBinContent(546,0.66);
    hrf->SetBinContent(547,0.58);
    hrf->SetBinContent(548,0.58);
    hrf->SetBinContent(549,0.54);
    hrf->SetBinContent(550,0.5);
    hrf->SetBinContent(551,0.54);
    hrf->SetBinContent(552,0.54);
    hrf->SetBinContent(553,0.46);
    hrf->SetBinContent(554,0.42);
    hrf->SetBinContent(555,0.46);
    hrf->SetBinContent(556,0.54);
    hrf->SetBinContent(557,0.5);
    hrf->SetBinContent(558,0.54);
    hrf->SetBinContent(559,0.46);
    hrf->SetBinContent(560,0.42);
    hrf->SetBinContent(561,0.5);
    hrf->SetBinContent(562,0.5);
    hrf->SetBinContent(563,0.62);
    hrf->SetBinContent(564,0.5);
    hrf->SetBinContent(565,0.62);
    hrf->SetBinContent(566,0.42);
    hrf->SetBinContent(567,0.46);
    hrf->SetBinContent(568,0.5);
    hrf->SetBinContent(569,0.5);
    hrf->SetBinContent(570,0.5);
    hrf->SetBinContent(571,0.5);
    hrf->SetBinContent(572,0.58);
    hrf->SetBinContent(573,0.42);
    hrf->SetBinContent(574,0.46);
    hrf->SetBinContent(575,0.58);
    hrf->SetBinContent(576,0.42);
    hrf->SetBinContent(577,0.46);
    hrf->SetBinContent(578,0.5);
    hrf->SetBinContent(579,0.5);
    hrf->SetBinContent(580,0.46);
    hrf->SetBinContent(581,0.42);
    hrf->SetBinContent(582,0.5);
    hrf->SetBinContent(583,0.46);
    hrf->SetBinContent(584,0.5);
    hrf->SetBinContent(585,0.58);
    hrf->SetBinContent(586,0.58);
    hrf->SetBinContent(587,0.62);
    hrf->SetBinContent(588,0.7);
    hrf->SetBinContent(589,0.66);
    hrf->SetBinContent(590,0.7);
    hrf->SetBinContent(591,0.7);
    hrf->SetBinContent(592,0.7);
    hrf->SetBinContent(595,0.74);
    hrf->SetBinContent(596,0.74);
    hrf->SetBinContent(597,0.7);
    hrf->SetBinContent(598,0.78);
    hrf->SetBinContent(599,0.7);
    hrf->SetBinContent(600,0.7);
    hrf->SetBinContent(601,0.66);
    hrf->SetBinContent(602,0.54);
    hrf->SetBinContent(603,0.7);
    hrf->SetBinContent(604,0.54);
    hrf->SetBinContent(605,0.58);
    hrf->SetBinContent(606,0.54);
    hrf->SetBinContent(607,0.46);
    hrf->SetBinContent(608,0.58);
    hrf->SetBinContent(609,0.58);
    hrf->SetBinContent(610,0.5);
    hrf->SetBinContent(611,0.5);
    hrf->SetBinContent(612,0.5);
    hrf->SetBinContent(613,0.58);
    hrf->SetBinContent(614,0.46);
    hrf->SetBinContent(615,0.54);
    hrf->SetBinContent(616,0.58);
    hrf->SetBinContent(617,0.5);
    hrf->SetBinContent(618,0.5);
    hrf->SetBinContent(619,0.5);
    hrf->SetBinContent(620,0.5);
    hrf->SetBinContent(621,0.5);
    hrf->SetBinContent(622,0.54);
    hrf->SetBinContent(623,0.46);
    hrf->SetBinContent(624,0.54);
    hrf->SetBinContent(625,0.54);
    hrf->SetBinContent(626,0.54);
    hrf->SetBinContent(627,0.54);
    hrf->SetBinContent(628,0.54);
    hrf->SetBinContent(629,0.5);
    hrf->SetBinContent(630,0.5);
    hrf->SetBinContent(631,0.46);
    hrf->SetBinContent(632,0.46);
    hrf->SetBinContent(633,0.46);
    hrf->SetBinContent(634,0.5);
    hrf->SetBinContent(635,0.46);
    hrf->SetBinContent(636,0.46);
    hrf->SetBinContent(637,0.5);
    hrf->SetBinContent(638,0.66);
    hrf->SetBinContent(639,0.62);
    hrf->SetBinContent(640,0.62);
    hrf->SetBinContent(641,0.66);
    hrf->SetBinContent(642,0.66);
    hrf->SetBinContent(643,0.58);
    hrf->SetBinContent(644,0.66);
    hrf->SetBinContent(645,0.66);
    hrf->SetBinContent(646,0.74);
    hrf->SetBinContent(649,0.7);
    hrf->SetBinContent(650,0.74);
    hrf->SetBinContent(651,0.74);
    hrf->SetBinContent(652,0.78);
    hrf->SetBinContent(653,0.7);
    hrf->SetBinContent(654,0.7);
    hrf->SetBinContent(655,0.62);
    hrf->SetBinContent(656,0.66);
    hrf->SetBinContent(657,0.74);
    hrf->SetBinContent(658,0.46);
    hrf->SetBinContent(659,0.54);
    hrf->SetBinContent(660,0.5);
    hrf->SetBinContent(661,0.54);
    hrf->SetBinContent(662,0.58);
    hrf->SetBinContent(663,0.42);
    hrf->SetBinContent(664,0.54);
    hrf->SetBinContent(665,0.58);
    hrf->SetBinContent(666,0.62);
    hrf->SetBinContent(667,0.58);
    hrf->SetBinContent(668,0.58);
    hrf->SetBinContent(669,0.58);
    hrf->SetBinContent(670,0.62);
    hrf->SetBinContent(671,0.46);
    hrf->SetBinContent(672,0.5);
    hrf->SetBinContent(673,0.62);
    hrf->SetBinContent(674,0.62);
    hrf->SetBinContent(675,0.66);
    hrf->SetBinContent(676,0.5);
    hrf->SetBinContent(677,0.66);
    hrf->SetBinContent(678,0.5);
    hrf->SetBinContent(679,0.5);
    hrf->SetBinContent(680,0.58);
    hrf->SetBinContent(681,0.54);
    hrf->SetBinContent(682,0.54);
    hrf->SetBinContent(683,0.58);
    hrf->SetBinContent(684,0.62);
    hrf->SetBinContent(685,0.5);
    hrf->SetBinContent(686,0.5);
    hrf->SetBinContent(687,0.54);
    hrf->SetBinContent(688,0.54);
    hrf->SetBinContent(689,0.66);
    hrf->SetBinContent(690,0.58);
    hrf->SetBinContent(691,0.54);
    hrf->SetBinContent(692,0.7);
    hrf->SetBinContent(693,0.7);
    hrf->SetBinContent(694,0.62);
    hrf->SetBinContent(695,0.62);
    hrf->SetBinContent(696,0.66);
    hrf->SetBinContent(697,0.74);
    hrf->SetBinContent(698,0.7);
    hrf->SetBinContent(699,0.74);
    hrf->SetBinContent(700,0.74);
    hrf->SetBinContent(703,0.7);
    hrf->SetBinContent(704,0.78);
    hrf->SetBinContent(705,0.66);
    hrf->SetBinContent(706,0.66);
    hrf->SetBinContent(707,0.66);
    hrf->SetBinContent(708,0.74);
    hrf->SetBinContent(709,0.7);
    hrf->SetBinContent(710,0.66);
    hrf->SetBinContent(711,0.58);
    hrf->SetBinContent(712,0.54);
    hrf->SetBinContent(713,0.58);
    hrf->SetBinContent(714,0.5);
    hrf->SetBinContent(715,0.54);
    hrf->SetBinContent(716,0.66);
    hrf->SetBinContent(717,0.54);
    hrf->SetBinContent(718,0.58);
    hrf->SetBinContent(719,0.66);
    hrf->SetBinContent(720,0.46);
    hrf->SetBinContent(721,0.58);
    hrf->SetBinContent(722,0.5);
    hrf->SetBinContent(723,0.58);
    hrf->SetBinContent(724,0.54);
    hrf->SetBinContent(725,0.58);
    hrf->SetBinContent(726,0.66);
    hrf->SetBinContent(727,0.58);
    hrf->SetBinContent(728,0.62);
    hrf->SetBinContent(729,0.58);
    hrf->SetBinContent(730,0.54);
    hrf->SetBinContent(731,0.54);
    hrf->SetBinContent(732,0.66);
    hrf->SetBinContent(733,0.5);
    hrf->SetBinContent(734,0.62);
    hrf->SetBinContent(735,0.62);
    hrf->SetBinContent(736,0.5);
    hrf->SetBinContent(737,0.54);
    hrf->SetBinContent(738,0.62);
    hrf->SetBinContent(739,0.62);
    hrf->SetBinContent(740,0.58);
    hrf->SetBinContent(741,0.58);
    hrf->SetBinContent(742,0.46);
    hrf->SetBinContent(743,0.46);
    hrf->SetBinContent(744,0.58);
    hrf->SetBinContent(745,0.5);
    hrf->SetBinContent(746,0.66);
    hrf->SetBinContent(747,0.66);
    hrf->SetBinContent(748,0.54);
    hrf->SetBinContent(749,0.78);
    hrf->SetBinContent(750,0.62);
    hrf->SetBinContent(751,0.7);
    hrf->SetBinContent(752,0.66);
    hrf->SetBinContent(753,0.66);
    hrf->SetBinContent(754,0.78);
    hrf->SetBinContent(757,0.82);
    hrf->SetBinContent(758,0.74);
    hrf->SetBinContent(759,0.7);
    hrf->SetBinContent(760,0.78);
    hrf->SetBinContent(761,0.7);
    hrf->SetBinContent(762,0.62);
    hrf->SetBinContent(763,0.78);
    hrf->SetBinContent(764,0.78);
    hrf->SetBinContent(765,0.7);
    hrf->SetBinContent(766,0.62);
    hrf->SetBinContent(767,0.58);
    hrf->SetBinContent(768,0.62);
    hrf->SetBinContent(769,0.66);
    hrf->SetBinContent(770,0.58);
    hrf->SetBinContent(771,0.66);
    hrf->SetBinContent(772,0.54);
    hrf->SetBinContent(773,0.7);
    hrf->SetBinContent(774,0.58);
    hrf->SetBinContent(775,0.58);
    hrf->SetBinContent(776,0.62);
    hrf->SetBinContent(777,0.7);
    hrf->SetBinContent(778,0.62);
    hrf->SetBinContent(779,0.66);
    hrf->SetBinContent(780,0.74);
    hrf->SetBinContent(781,0.54);
    hrf->SetBinContent(782,0.58);
    hrf->SetBinContent(783,0.54);
    hrf->SetBinContent(784,0.62);
    hrf->SetBinContent(785,0.62);
    hrf->SetBinContent(786,0.54);
    hrf->SetBinContent(787,0.54);
    hrf->SetBinContent(788,0.62);
    hrf->SetBinContent(789,0.5);
    hrf->SetBinContent(790,0.58);
    hrf->SetBinContent(791,0.74);
    hrf->SetBinContent(792,0.54);
    hrf->SetBinContent(793,0.58);
    hrf->SetBinContent(794,0.58);
    hrf->SetBinContent(795,0.54);
    hrf->SetBinContent(796,0.62);
    hrf->SetBinContent(797,0.58);
    hrf->SetBinContent(798,0.58);
    hrf->SetBinContent(799,0.7);
    hrf->SetBinContent(800,0.62);
    hrf->SetBinContent(801,0.7);
    hrf->SetBinContent(802,0.7);
    hrf->SetBinContent(803,0.82);
    hrf->SetBinContent(804,0.74);
    hrf->SetBinContent(805,0.74);
    hrf->SetBinContent(806,0.74);
    hrf->SetBinContent(807,0.74);
    hrf->SetBinContent(808,0.74);
    hrf->SetBinContent(811,0.78);
    hrf->SetBinContent(812,0.78);
    hrf->SetBinContent(813,0.86);
    hrf->SetBinContent(814,0.78);
    hrf->SetBinContent(815,0.78);
    hrf->SetBinContent(816,0.82);
    hrf->SetBinContent(817,0.82);
    hrf->SetBinContent(818,0.7);
    hrf->SetBinContent(819,0.7);
    hrf->SetBinContent(820,0.58);
    hrf->SetBinContent(821,0.58);
    hrf->SetBinContent(822,0.66);
    hrf->SetBinContent(823,0.62);
    hrf->SetBinContent(824,0.7);
    hrf->SetBinContent(825,0.58);
    hrf->SetBinContent(826,0.66);
    hrf->SetBinContent(827,0.54);
    hrf->SetBinContent(828,0.62);
    hrf->SetBinContent(829,0.62);
    hrf->SetBinContent(830,0.7);
    hrf->SetBinContent(831,0.78);
    hrf->SetBinContent(832,0.66);
    hrf->SetBinContent(833,0.62);
    hrf->SetBinContent(834,0.66);
    hrf->SetBinContent(835,0.66);
    hrf->SetBinContent(836,0.62);
    hrf->SetBinContent(837,0.66);
    hrf->SetBinContent(838,0.66);
    hrf->SetBinContent(839,0.66);
    hrf->SetBinContent(840,0.78);
    hrf->SetBinContent(841,0.66);
    hrf->SetBinContent(842,0.62);
    hrf->SetBinContent(843,0.66);
    hrf->SetBinContent(844,0.66);
    hrf->SetBinContent(845,0.7);
    hrf->SetBinContent(846,0.7);
    hrf->SetBinContent(847,0.58);
    hrf->SetBinContent(848,0.66);
    hrf->SetBinContent(849,0.78);
    hrf->SetBinContent(850,0.7);
    hrf->SetBinContent(851,0.62);
    hrf->SetBinContent(852,0.62);
    hrf->SetBinContent(853,0.7);
    hrf->SetBinContent(854,0.82);
    hrf->SetBinContent(855,0.66);
    hrf->SetBinContent(856,0.7);
    hrf->SetBinContent(857,0.74);
    hrf->SetBinContent(858,0.66);
    hrf->SetBinContent(859,0.74);
    hrf->SetBinContent(860,0.7);
    hrf->SetBinContent(861,0.78);
    hrf->SetBinContent(862,0.82);
    hrf->SetBinContent(865,0.78);
    hrf->SetBinContent(866,0.74);
    hrf->SetBinContent(867,0.78);
    hrf->SetBinContent(868,0.82);
    hrf->SetBinContent(869,0.78);
    hrf->SetBinContent(870,0.66);
    hrf->SetBinContent(871,0.74);
    hrf->SetBinContent(872,0.7);
    hrf->SetBinContent(873,0.86);
    hrf->SetBinContent(874,0.58);
    hrf->SetBinContent(875,0.62);
    hrf->SetBinContent(876,0.62);
    hrf->SetBinContent(877,0.74);
    hrf->SetBinContent(878,0.66);
    hrf->SetBinContent(879,0.66);
    hrf->SetBinContent(880,0.58);
    hrf->SetBinContent(881,0.66);
    hrf->SetBinContent(882,0.62);
    hrf->SetBinContent(883,0.7);
    hrf->SetBinContent(884,0.66);
    hrf->SetBinContent(885,0.74);
    hrf->SetBinContent(886,0.7);
    hrf->SetBinContent(887,0.62);
    hrf->SetBinContent(888,0.58);
    hrf->SetBinContent(889,0.66);
    hrf->SetBinContent(890,0.62);
    hrf->SetBinContent(891,0.66);
    hrf->SetBinContent(892,0.66);
    hrf->SetBinContent(893,0.74);
    hrf->SetBinContent(894,0.7);
    hrf->SetBinContent(895,0.58);
    hrf->SetBinContent(896,0.7);
    hrf->SetBinContent(897,0.66);
    hrf->SetBinContent(898,0.7);
    hrf->SetBinContent(899,0.66);
    hrf->SetBinContent(900,0.7);
    hrf->SetBinContent(901,0.62);
    hrf->SetBinContent(902,0.58);
    hrf->SetBinContent(903,0.7);
    hrf->SetBinContent(904,0.7);
    hrf->SetBinContent(905,0.7);
    hrf->SetBinContent(906,0.66);
    hrf->SetBinContent(907,0.7);
    hrf->SetBinContent(908,0.74);
    hrf->SetBinContent(909,0.7);
    hrf->SetBinContent(910,0.74);
    hrf->SetBinContent(911,0.74);
    hrf->SetBinContent(912,0.66);
    hrf->SetBinContent(913,0.82);
    hrf->SetBinContent(914,0.78);
    hrf->SetBinContent(915,0.78);
    hrf->SetBinContent(916,0.82);
    hrf->SetBinContent(919,0.86);
    hrf->SetBinContent(920,0.78);
    hrf->SetBinContent(921,0.78);
    hrf->SetBinContent(922,0.78);
    hrf->SetBinContent(923,0.86);
    hrf->SetBinContent(924,0.78);
    hrf->SetBinContent(925,0.7);
    hrf->SetBinContent(926,0.78);
    hrf->SetBinContent(927,0.74);
    hrf->SetBinContent(928,0.62);
    hrf->SetBinContent(929,0.62);
    hrf->SetBinContent(930,0.7);
    hrf->SetBinContent(931,0.78);
    hrf->SetBinContent(932,0.66);
    hrf->SetBinContent(933,0.7);
    hrf->SetBinContent(934,0.7);
    hrf->SetBinContent(935,0.66);
    hrf->SetBinContent(936,0.62);
    hrf->SetBinContent(937,0.7);
    hrf->SetBinContent(938,0.7);
    hrf->SetBinContent(939,0.62);
    hrf->SetBinContent(940,0.74);
    hrf->SetBinContent(941,0.66);
    hrf->SetBinContent(942,0.62);
    hrf->SetBinContent(943,0.66);
    hrf->SetBinContent(944,0.74);
    hrf->SetBinContent(945,0.66);
    hrf->SetBinContent(946,0.66);
    hrf->SetBinContent(947,0.74);
    hrf->SetBinContent(948,0.66);
    hrf->SetBinContent(949,0.66);
    hrf->SetBinContent(950,0.62);
    hrf->SetBinContent(951,0.74);
    hrf->SetBinContent(952,0.74);
    hrf->SetBinContent(953,0.66);
    hrf->SetBinContent(954,0.66);
    hrf->SetBinContent(955,0.7);
    hrf->SetBinContent(956,0.58);
    hrf->SetBinContent(957,0.7);
    hrf->SetBinContent(958,0.66);
    hrf->SetBinContent(959,0.7);
    hrf->SetBinContent(960,0.62);
    hrf->SetBinContent(961,0.7);
    hrf->SetBinContent(962,0.82);
    hrf->SetBinContent(963,0.66);
    hrf->SetBinContent(964,0.74);
    hrf->SetBinContent(965,0.7);
    hrf->SetBinContent(966,0.74);
    hrf->SetBinContent(967,0.78);
    hrf->SetBinContent(968,0.86);
    hrf->SetBinContent(969,0.78);
    hrf->SetBinContent(970,0.78);
    hrf->SetBinContent(973,0.82);
    hrf->SetBinContent(974,0.82);
    hrf->SetBinContent(975,0.74);
    hrf->SetBinContent(976,0.7);
    hrf->SetBinContent(977,0.78);
    hrf->SetBinContent(978,0.74);
    hrf->SetBinContent(979,0.82);
    hrf->SetBinContent(980,0.7);
    hrf->SetBinContent(981,0.74);
    hrf->SetBinContent(982,0.62);
    hrf->SetBinContent(983,0.7);
    hrf->SetBinContent(984,0.7);
    hrf->SetBinContent(985,0.66);
    hrf->SetBinContent(986,0.78);
    hrf->SetBinContent(987,0.62);
    hrf->SetBinContent(988,0.74);
    hrf->SetBinContent(989,0.7);
    hrf->SetBinContent(990,0.7);
    hrf->SetBinContent(991,0.7);
    hrf->SetBinContent(992,0.7);
    hrf->SetBinContent(993,0.82);
    hrf->SetBinContent(994,0.86);
    hrf->SetBinContent(995,0.7);
    hrf->SetBinContent(996,0.7);
    hrf->SetBinContent(997,0.78);
    hrf->SetBinContent(998,0.66);
    hrf->SetBinContent(999,0.74);
    hrf->SetBinContent(1000,0.86);
    hrf->SetBinContent(1001,0.66);
    hrf->SetBinContent(1002,0.66);
    hrf->SetBinContent(1003,0.74);
    hrf->SetBinContent(1004,0.7);
    hrf->SetBinContent(1005,0.62);
    hrf->SetBinContent(1006,0.66);
    hrf->SetBinContent(1007,0.78);
    hrf->SetBinContent(1008,0.7);
    hrf->SetBinContent(1009,0.74);
    hrf->SetBinContent(1010,0.66);
    hrf->SetBinContent(1011,0.78);
    hrf->SetBinContent(1012,0.62);
    hrf->SetBinContent(1013,0.7);
    hrf->SetBinContent(1014,0.58);
    hrf->SetBinContent(1015,0.74);
    hrf->SetBinContent(1016,0.74);
    hrf->SetBinContent(1017,0.7);
    hrf->SetBinContent(1018,0.7);
    hrf->SetBinContent(1019,0.74);
    hrf->SetBinContent(1020,0.78);
    hrf->SetBinContent(1021,0.74);
    hrf->SetBinContent(1022,0.86);
    hrf->SetBinContent(1023,0.86);
    hrf->SetBinContent(1024,0.82);
    hrf->SetBinContent(1027,0.82);
    hrf->SetBinContent(1028,0.82);
    hrf->SetBinContent(1029,0.78);
    hrf->SetBinContent(1030,0.78);
    hrf->SetBinContent(1031,0.78);
    hrf->SetBinContent(1032,0.78);
    hrf->SetBinContent(1033,0.78);
    hrf->SetBinContent(1034,0.78);
    hrf->SetBinContent(1035,0.9);
    hrf->SetBinContent(1036,0.74);
    hrf->SetBinContent(1037,0.62);
    hrf->SetBinContent(1038,0.7);
    hrf->SetBinContent(1039,0.66);
    hrf->SetBinContent(1040,0.7);
    hrf->SetBinContent(1041,0.74);
    hrf->SetBinContent(1042,0.74);
    hrf->SetBinContent(1043,0.74);
    hrf->SetBinContent(1044,0.7);
    hrf->SetBinContent(1045,0.62);
    hrf->SetBinContent(1046,0.74);
    hrf->SetBinContent(1047,0.78);
    hrf->SetBinContent(1048,0.74);
    hrf->SetBinContent(1049,0.78);
    hrf->SetBinContent(1050,0.78);
    hrf->SetBinContent(1051,0.78);
    hrf->SetBinContent(1052,0.74);
    hrf->SetBinContent(1053,0.74);
    hrf->SetBinContent(1054,0.78);
    hrf->SetBinContent(1055,0.74);
    hrf->SetBinContent(1056,0.78);
    hrf->SetBinContent(1057,0.74);
    hrf->SetBinContent(1058,0.74);
    hrf->SetBinContent(1059,0.74);
    hrf->SetBinContent(1060,0.74);
    hrf->SetBinContent(1061,0.7);
    hrf->SetBinContent(1062,0.7);
    hrf->SetBinContent(1063,0.66);
    hrf->SetBinContent(1064,0.74);
    hrf->SetBinContent(1065,0.74);
    hrf->SetBinContent(1066,0.7);
    hrf->SetBinContent(1067,0.7);
    hrf->SetBinContent(1068,0.62);
    hrf->SetBinContent(1069,0.74);
    hrf->SetBinContent(1070,0.7);
    hrf->SetBinContent(1071,0.74);
    hrf->SetBinContent(1072,0.74);
    hrf->SetBinContent(1073,0.82);
    hrf->SetBinContent(1074,0.82);
    hrf->SetBinContent(1075,0.86);
    hrf->SetBinContent(1076,0.78);
    hrf->SetBinContent(1077,0.82);
    hrf->SetBinContent(1078,0.86);
    hrf->SetBinContent(1081,0.86);
    hrf->SetBinContent(1082,0.82);
    hrf->SetBinContent(1083,0.78);
    hrf->SetBinContent(1084,0.78);
    hrf->SetBinContent(1085,0.82);
    hrf->SetBinContent(1086,0.82);
    hrf->SetBinContent(1087,0.82);
    hrf->SetBinContent(1088,0.78);
    hrf->SetBinContent(1089,0.86);
    hrf->SetBinContent(1090,0.74);
    hrf->SetBinContent(1091,0.78);
    hrf->SetBinContent(1092,0.74);
    hrf->SetBinContent(1093,0.7);
    hrf->SetBinContent(1094,0.66);
    hrf->SetBinContent(1095,0.78);
    hrf->SetBinContent(1096,0.74);
    hrf->SetBinContent(1097,0.78);
    hrf->SetBinContent(1098,0.78);
    hrf->SetBinContent(1099,0.78);
    hrf->SetBinContent(1100,0.74);
    hrf->SetBinContent(1101,0.7);
    hrf->SetBinContent(1102,0.82);
    hrf->SetBinContent(1103,0.78);
    hrf->SetBinContent(1104,0.86);
    hrf->SetBinContent(1105,0.78);
    hrf->SetBinContent(1106,0.74);
    hrf->SetBinContent(1107,0.78);
    hrf->SetBinContent(1108,0.74);
    hrf->SetBinContent(1109,0.82);
    hrf->SetBinContent(1110,0.74);
    hrf->SetBinContent(1111,0.82);
    hrf->SetBinContent(1112,0.74);
    hrf->SetBinContent(1113,0.86);
    hrf->SetBinContent(1114,0.82);
    hrf->SetBinContent(1115,0.74);
    hrf->SetBinContent(1116,0.78);
    hrf->SetBinContent(1117,0.74);
    hrf->SetBinContent(1118,0.7);
    hrf->SetBinContent(1119,0.66);
    hrf->SetBinContent(1120,0.66);
    hrf->SetBinContent(1121,0.74);
    hrf->SetBinContent(1122,0.66);
    hrf->SetBinContent(1123,0.7);
    hrf->SetBinContent(1124,0.82);
    hrf->SetBinContent(1125,0.86);
    hrf->SetBinContent(1126,0.74);
    hrf->SetBinContent(1127,0.78);
    hrf->SetBinContent(1128,0.82);
    hrf->SetBinContent(1129,0.78);
    hrf->SetBinContent(1130,0.82);
    hrf->SetBinContent(1131,0.86);
    hrf->SetBinContent(1132,0.82);
    hrf->SetBinContent(1135,0.86);
    hrf->SetBinContent(1136,0.86);
    hrf->SetBinContent(1137,0.9);
    hrf->SetBinContent(1138,0.78);
    hrf->SetBinContent(1139,0.9);
    hrf->SetBinContent(1140,0.86);
    hrf->SetBinContent(1141,0.82);
    hrf->SetBinContent(1142,0.78);
    hrf->SetBinContent(1143,0.86);
    hrf->SetBinContent(1144,0.7);
    hrf->SetBinContent(1145,0.7);
    hrf->SetBinContent(1146,0.74);
    hrf->SetBinContent(1147,0.62);
    hrf->SetBinContent(1148,0.74);
    hrf->SetBinContent(1149,0.74);
    hrf->SetBinContent(1150,0.78);
    hrf->SetBinContent(1151,0.74);
    hrf->SetBinContent(1152,0.74);
    hrf->SetBinContent(1153,0.78);
    hrf->SetBinContent(1154,0.78);
    hrf->SetBinContent(1155,0.78);
    hrf->SetBinContent(1156,0.82);
    hrf->SetBinContent(1157,0.74);
    hrf->SetBinContent(1158,0.78);
    hrf->SetBinContent(1159,0.78);
    hrf->SetBinContent(1160,0.74);
    hrf->SetBinContent(1161,0.78);
    hrf->SetBinContent(1162,0.82);
    hrf->SetBinContent(1163,0.78);
    hrf->SetBinContent(1164,0.78);
    hrf->SetBinContent(1165,0.82);
    hrf->SetBinContent(1166,0.7);
    hrf->SetBinContent(1167,0.78);
    hrf->SetBinContent(1168,0.7);
    hrf->SetBinContent(1169,0.82);
    hrf->SetBinContent(1170,0.74);
    hrf->SetBinContent(1171,0.74);
    hrf->SetBinContent(1172,0.78);
    hrf->SetBinContent(1173,0.74);
    hrf->SetBinContent(1174,0.66);
    hrf->SetBinContent(1175,0.7);
    hrf->SetBinContent(1176,0.7);
    hrf->SetBinContent(1177,0.74);
    hrf->SetBinContent(1178,0.86);
    hrf->SetBinContent(1179,0.86);
    hrf->SetBinContent(1180,0.78);
    hrf->SetBinContent(1181,0.78);
    hrf->SetBinContent(1182,0.82);
    hrf->SetBinContent(1183,0.82);
    hrf->SetBinContent(1184,0.86);
    hrf->SetBinContent(1185,0.86);
    hrf->SetBinContent(1186,0.82);
    hrf->SetBinContent(1189,0.86);
    hrf->SetBinContent(1190,0.82);
    hrf->SetBinContent(1191,0.86);
    hrf->SetBinContent(1192,0.82);
    hrf->SetBinContent(1193,0.86);
    hrf->SetBinContent(1194,0.86);
    hrf->SetBinContent(1195,0.78);
    hrf->SetBinContent(1196,0.86);
    hrf->SetBinContent(1197,0.82);
    hrf->SetBinContent(1198,0.74);
    hrf->SetBinContent(1199,0.74);
    hrf->SetBinContent(1200,0.74);
    hrf->SetBinContent(1201,0.74);
    hrf->SetBinContent(1202,0.7);
    hrf->SetBinContent(1203,0.7);
    hrf->SetBinContent(1204,0.82);
    hrf->SetBinContent(1205,0.74);
    hrf->SetBinContent(1206,0.82);
    hrf->SetBinContent(1207,0.82);
    hrf->SetBinContent(1208,0.78);
    hrf->SetBinContent(1209,0.82);
    hrf->SetBinContent(1210,0.82);
    hrf->SetBinContent(1211,0.82);
    hrf->SetBinContent(1212,0.78);
    hrf->SetBinContent(1213,0.82);
    hrf->SetBinContent(1214,0.78);
    hrf->SetBinContent(1215,0.82);
    hrf->SetBinContent(1216,0.86);
    hrf->SetBinContent(1217,0.74);
    hrf->SetBinContent(1218,0.82);
    hrf->SetBinContent(1219,0.82);
    hrf->SetBinContent(1220,0.78);
    hrf->SetBinContent(1221,0.78);
    hrf->SetBinContent(1222,0.7);
    hrf->SetBinContent(1223,0.74);
    hrf->SetBinContent(1224,0.82);
    hrf->SetBinContent(1225,0.7);
    hrf->SetBinContent(1226,0.78);
    hrf->SetBinContent(1227,0.74);
    hrf->SetBinContent(1228,0.7);
    hrf->SetBinContent(1229,0.7);
    hrf->SetBinContent(1230,0.66);
    hrf->SetBinContent(1231,0.74);
    hrf->SetBinContent(1232,0.78);
    hrf->SetBinContent(1233,0.82);
    hrf->SetBinContent(1234,0.82);
    hrf->SetBinContent(1235,0.78);
    hrf->SetBinContent(1236,0.82);
    hrf->SetBinContent(1237,0.82);
    hrf->SetBinContent(1238,0.82);
    hrf->SetBinContent(1239,0.82);
    hrf->SetBinContent(1240,0.86);
    hrf->SetBinContent(1243,0.86);
    hrf->SetBinContent(1244,0.86);
    hrf->SetBinContent(1245,0.82);
    hrf->SetBinContent(1246,0.86);
    hrf->SetBinContent(1247,0.9);
    hrf->SetBinContent(1248,0.82);
    hrf->SetBinContent(1249,0.86);
    hrf->SetBinContent(1250,0.82);
    hrf->SetBinContent(1251,0.82);
    hrf->SetBinContent(1252,0.78);
    hrf->SetBinContent(1253,0.78);
    hrf->SetBinContent(1254,0.66);
    hrf->SetBinContent(1255,0.7);
    hrf->SetBinContent(1256,0.74);
    hrf->SetBinContent(1257,0.78);
    hrf->SetBinContent(1258,0.78);
    hrf->SetBinContent(1259,0.82);
    hrf->SetBinContent(1260,0.86);
    hrf->SetBinContent(1261,0.82);
    hrf->SetBinContent(1262,0.82);
    hrf->SetBinContent(1263,0.82);
    hrf->SetBinContent(1264,0.78);
    hrf->SetBinContent(1265,0.9);
    hrf->SetBinContent(1266,0.78);
    hrf->SetBinContent(1267,0.82);
    hrf->SetBinContent(1268,0.78);
    hrf->SetBinContent(1269,0.78);
    hrf->SetBinContent(1270,0.78);
    hrf->SetBinContent(1271,0.78);
    hrf->SetBinContent(1272,0.78);
    hrf->SetBinContent(1273,0.86);
    hrf->SetBinContent(1274,0.78);
    hrf->SetBinContent(1275,0.78);
    hrf->SetBinContent(1276,0.74);
    hrf->SetBinContent(1277,0.78);
    hrf->SetBinContent(1278,0.7);
    hrf->SetBinContent(1279,0.7);
    hrf->SetBinContent(1280,0.74);
    hrf->SetBinContent(1281,0.74);
    hrf->SetBinContent(1282,0.74);
    hrf->SetBinContent(1283,0.78);
    hrf->SetBinContent(1284,0.82);
    hrf->SetBinContent(1285,0.74);
    hrf->SetBinContent(1286,0.86);
    hrf->SetBinContent(1287,0.78);
    hrf->SetBinContent(1288,0.86);
    hrf->SetBinContent(1289,0.78);
    hrf->SetBinContent(1290,0.82);
    hrf->SetBinContent(1291,0.86);
    hrf->SetBinContent(1292,0.82);
    hrf->SetBinContent(1293,0.86);
    hrf->SetBinContent(1294,0.82);
    hrf->SetBinContent(1297,0.86);
    hrf->SetBinContent(1298,0.86);
    hrf->SetBinContent(1299,0.82);
    hrf->SetBinContent(1300,0.82);
    hrf->SetBinContent(1301,0.86);
    hrf->SetBinContent(1302,0.82);
    hrf->SetBinContent(1303,0.82);
    hrf->SetBinContent(1304,0.86);
    hrf->SetBinContent(1305,0.86);
    hrf->SetBinContent(1306,0.78);
    hrf->SetBinContent(1307,0.74);
    hrf->SetBinContent(1308,0.7);
    hrf->SetBinContent(1309,0.66);
    hrf->SetBinContent(1310,0.74);
    hrf->SetBinContent(1311,0.74);
    hrf->SetBinContent(1312,0.78);
    hrf->SetBinContent(1313,0.78);
    hrf->SetBinContent(1314,0.78);
    hrf->SetBinContent(1315,0.82);
    hrf->SetBinContent(1316,0.78);
    hrf->SetBinContent(1317,0.82);
    hrf->SetBinContent(1318,0.78);
    hrf->SetBinContent(1319,0.78);
    hrf->SetBinContent(1320,0.78);
    hrf->SetBinContent(1321,0.82);
    hrf->SetBinContent(1322,0.86);
    hrf->SetBinContent(1323,0.82);
    hrf->SetBinContent(1324,0.82);
    hrf->SetBinContent(1325,0.82);
    hrf->SetBinContent(1326,0.74);
    hrf->SetBinContent(1327,0.78);
    hrf->SetBinContent(1328,0.82);
    hrf->SetBinContent(1329,0.78);
    hrf->SetBinContent(1330,0.74);
    hrf->SetBinContent(1331,0.82);
    hrf->SetBinContent(1332,0.78);
    hrf->SetBinContent(1333,0.78);
    hrf->SetBinContent(1334,0.78);
    hrf->SetBinContent(1335,0.74);
    hrf->SetBinContent(1336,0.78);
    hrf->SetBinContent(1337,0.78);
    hrf->SetBinContent(1338,0.7);
    hrf->SetBinContent(1339,0.7);
    hrf->SetBinContent(1340,0.86);
    hrf->SetBinContent(1341,0.82);
    hrf->SetBinContent(1342,0.82);
    hrf->SetBinContent(1343,0.82);
    hrf->SetBinContent(1344,0.86);
    hrf->SetBinContent(1345,0.86);
    hrf->SetBinContent(1346,0.86);
    hrf->SetBinContent(1347,0.9);
    hrf->SetBinContent(1348,0.86);
    hrf->SetBinContent(1351,0.86);
    hrf->SetBinContent(1352,0.82);
    hrf->SetBinContent(1353,0.9);
    hrf->SetBinContent(1354,0.86);
    hrf->SetBinContent(1355,0.86);
    hrf->SetBinContent(1356,0.9);
    hrf->SetBinContent(1357,0.82);
    hrf->SetBinContent(1358,0.86);
    hrf->SetBinContent(1359,0.9);
    hrf->SetBinContent(1360,0.74);
    hrf->SetBinContent(1361,0.78);
    hrf->SetBinContent(1362,0.78);
    hrf->SetBinContent(1363,0.74);
    hrf->SetBinContent(1364,0.78);
    hrf->SetBinContent(1365,0.74);
    hrf->SetBinContent(1366,0.82);
    hrf->SetBinContent(1367,0.82);
    hrf->SetBinContent(1368,0.86);
    hrf->SetBinContent(1369,0.82);
    hrf->SetBinContent(1370,0.82);
    hrf->SetBinContent(1371,0.78);
    hrf->SetBinContent(1372,0.82);
    hrf->SetBinContent(1373,0.78);
    hrf->SetBinContent(1374,0.78);
    hrf->SetBinContent(1375,0.82);
    hrf->SetBinContent(1376,0.78);
    hrf->SetBinContent(1377,0.78);
    hrf->SetBinContent(1378,0.82);
    hrf->SetBinContent(1379,0.78);
    hrf->SetBinContent(1380,0.82);
    hrf->SetBinContent(1381,0.86);
    hrf->SetBinContent(1382,0.82);
    hrf->SetBinContent(1383,0.82);
    hrf->SetBinContent(1384,0.78);
    hrf->SetBinContent(1385,0.82);
    hrf->SetBinContent(1386,0.82);
    hrf->SetBinContent(1387,0.86);
    hrf->SetBinContent(1388,0.74);
    hrf->SetBinContent(1389,0.82);
    hrf->SetBinContent(1390,0.7);
    hrf->SetBinContent(1391,0.7);
    hrf->SetBinContent(1392,0.78);
    hrf->SetBinContent(1393,0.78);
    hrf->SetBinContent(1394,0.9);
    hrf->SetBinContent(1395,0.86);
    hrf->SetBinContent(1396,0.86);
    hrf->SetBinContent(1397,0.9);
    hrf->SetBinContent(1398,0.86);
    hrf->SetBinContent(1399,0.9);
    hrf->SetBinContent(1400,0.82);
    hrf->SetBinContent(1401,0.9);
    hrf->SetBinContent(1402,0.9);
    hrf->SetBinContent(1405,0.9);
    hrf->SetBinContent(1406,0.86);
    hrf->SetBinContent(1407,0.86);
    hrf->SetBinContent(1408,0.94);
    hrf->SetBinContent(1409,0.86);
    hrf->SetBinContent(1410,0.86);
    hrf->SetBinContent(1411,0.86);
    hrf->SetBinContent(1412,0.86);
    hrf->SetBinContent(1413,0.86);
    hrf->SetBinContent(1414,0.82);
    hrf->SetBinContent(1415,0.74);
    hrf->SetBinContent(1416,0.7);
    hrf->SetBinContent(1417,0.78);
    hrf->SetBinContent(1418,0.74);
    hrf->SetBinContent(1419,0.78);
    hrf->SetBinContent(1420,0.78);
    hrf->SetBinContent(1421,0.78);
    hrf->SetBinContent(1422,0.86);
    hrf->SetBinContent(1423,0.78);
    hrf->SetBinContent(1424,0.82);
    hrf->SetBinContent(1425,0.82);
    hrf->SetBinContent(1426,0.82);
    hrf->SetBinContent(1427,0.78);
    hrf->SetBinContent(1428,0.78);
    hrf->SetBinContent(1429,0.86);
    hrf->SetBinContent(1430,0.82);
    hrf->SetBinContent(1431,0.86);
    hrf->SetBinContent(1432,0.86);
    hrf->SetBinContent(1433,0.82);
    hrf->SetBinContent(1434,0.9);
    hrf->SetBinContent(1435,0.82);
    hrf->SetBinContent(1436,0.86);
    hrf->SetBinContent(1437,0.82);
    hrf->SetBinContent(1438,0.9);
    hrf->SetBinContent(1439,0.82);
    hrf->SetBinContent(1440,0.78);
    hrf->SetBinContent(1441,0.78);
    hrf->SetBinContent(1442,0.82);
    hrf->SetBinContent(1443,0.74);
    hrf->SetBinContent(1444,0.82);
    hrf->SetBinContent(1445,0.78);
    hrf->SetBinContent(1446,0.82);
    hrf->SetBinContent(1447,0.78);
    hrf->SetBinContent(1448,0.9);
    hrf->SetBinContent(1449,0.82);
    hrf->SetBinContent(1450,0.86);
    hrf->SetBinContent(1451,0.86);
    hrf->SetBinContent(1452,0.86);
    hrf->SetBinContent(1453,0.86);
    hrf->SetBinContent(1454,0.86);
    hrf->SetBinContent(1455,0.86);
    hrf->SetBinContent(1456,0.86);
    hrf->SetBinContent(1459,0.9);
    hrf->SetBinContent(1460,0.86);
    hrf->SetBinContent(1461,0.9);
    hrf->SetBinContent(1462,0.9);
    hrf->SetBinContent(1463,0.9);
    hrf->SetBinContent(1464,0.9);
    hrf->SetBinContent(1465,0.86);
    hrf->SetBinContent(1466,0.86);
    hrf->SetBinContent(1467,0.9);
    hrf->SetBinContent(1468,0.78);
    hrf->SetBinContent(1469,0.82);
    hrf->SetBinContent(1470,0.7);
    hrf->SetBinContent(1471,0.78);
    hrf->SetBinContent(1472,0.78);
    hrf->SetBinContent(1473,0.78);
    hrf->SetBinContent(1474,0.82);
    hrf->SetBinContent(1475,0.82);
    hrf->SetBinContent(1476,0.86);
    hrf->SetBinContent(1477,0.82);
    hrf->SetBinContent(1478,0.86);
    hrf->SetBinContent(1479,0.82);
    hrf->SetBinContent(1480,0.82);
    hrf->SetBinContent(1481,0.9);
    hrf->SetBinContent(1482,0.9);
    hrf->SetBinContent(1483,0.82);
    hrf->SetBinContent(1484,0.86);
    hrf->SetBinContent(1485,0.9);
    hrf->SetBinContent(1486,0.86);
    hrf->SetBinContent(1487,0.78);
    hrf->SetBinContent(1488,0.9);
    hrf->SetBinContent(1489,0.86);
    hrf->SetBinContent(1490,0.86);
    hrf->SetBinContent(1491,0.82);
    hrf->SetBinContent(1492,0.78);
    hrf->SetBinContent(1493,0.86);
    hrf->SetBinContent(1494,0.82);
    hrf->SetBinContent(1495,0.78);
    hrf->SetBinContent(1496,0.82);
    hrf->SetBinContent(1497,0.78);
    hrf->SetBinContent(1498,0.74);
    hrf->SetBinContent(1499,0.74);
    hrf->SetBinContent(1500,0.78);
    hrf->SetBinContent(1501,0.78);
    hrf->SetBinContent(1502,0.86);
    hrf->SetBinContent(1503,0.86);
    hrf->SetBinContent(1504,0.82);
    hrf->SetBinContent(1505,0.86);
    hrf->SetBinContent(1506,0.86);
    hrf->SetBinContent(1507,0.86);
    hrf->SetBinContent(1508,0.86);
    hrf->SetBinContent(1509,0.9);
    hrf->SetBinContent(1510,0.9);
    hrf->SetBinContent(1513,0.86);
    hrf->SetBinContent(1514,0.9);
    hrf->SetBinContent(1515,0.9);
    hrf->SetBinContent(1516,0.9);
    hrf->SetBinContent(1517,0.9);
    hrf->SetBinContent(1518,0.86);
    hrf->SetBinContent(1519,0.86);
    hrf->SetBinContent(1520,0.9);
    hrf->SetBinContent(1521,0.9);
    hrf->SetBinContent(1522,0.78);
    hrf->SetBinContent(1523,0.78);
    hrf->SetBinContent(1524,0.78);
    hrf->SetBinContent(1525,0.74);
    hrf->SetBinContent(1526,0.78);
    hrf->SetBinContent(1527,0.82);
    hrf->SetBinContent(1528,0.78);
    hrf->SetBinContent(1529,0.82);
    hrf->SetBinContent(1530,0.86);
    hrf->SetBinContent(1531,0.82);
    hrf->SetBinContent(1532,0.86);
    hrf->SetBinContent(1533,0.86);
    hrf->SetBinContent(1534,0.78);
    hrf->SetBinContent(1535,0.86);
    hrf->SetBinContent(1536,0.82);
    hrf->SetBinContent(1537,0.82);
    hrf->SetBinContent(1538,0.82);
    hrf->SetBinContent(1539,0.9);
    hrf->SetBinContent(1540,0.82);
    hrf->SetBinContent(1541,0.82);
    hrf->SetBinContent(1542,0.82);
    hrf->SetBinContent(1543,0.9);
    hrf->SetBinContent(1544,0.9);
    hrf->SetBinContent(1545,0.82);
    hrf->SetBinContent(1546,0.82);
    hrf->SetBinContent(1547,0.82);
    hrf->SetBinContent(1548,0.82);
    hrf->SetBinContent(1549,0.82);
    hrf->SetBinContent(1550,0.82);
    hrf->SetBinContent(1551,0.82);
    hrf->SetBinContent(1552,0.78);
    hrf->SetBinContent(1553,0.82);
    hrf->SetBinContent(1554,0.82);
    hrf->SetBinContent(1555,0.82);
    hrf->SetBinContent(1556,0.86);
    hrf->SetBinContent(1557,0.86);
    hrf->SetBinContent(1558,0.86);
    hrf->SetBinContent(1559,0.9);
    hrf->SetBinContent(1560,0.86);
    hrf->SetBinContent(1561,0.86);
    hrf->SetBinContent(1562,0.86);
    hrf->SetBinContent(1563,0.86);
    hrf->SetBinContent(1564,0.82);
 
    return hrf;
  }
}