/data/refman/pasoursint/CMSSW_5_3_10_patch2/src/RecoMET/METAlgorithms/src/TCMETAlgo.cc

Go to the documentation of this file.

// File: TCMETAlgo.cc
// Description:  see TCMETAlgo.h
// Author: F. Golf
// Creation Date:  March 24, 2009 Initial version.
//
//------------------------------------------------------------------------
#include "RecoMET/METAlgorithms/interface/TCMETAlgo.h"
#include "DataFormats/Candidate/interface/Candidate.h"
#include "DataFormats/Candidate/interface/CandidateFwd.h"
#include "DataFormats/METReco/interface/CommonMETData.h"
#include "DataFormats/Math/interface/LorentzVector.h"
#include "DataFormats/Math/interface/Point3D.h"
#include "DataFormats/RecoCandidate/interface/RecoCandidate.h"

#include "DataFormats/EgammaCandidates/interface/Electron.h"
#include "DataFormats/EgammaCandidates/interface/ElectronFwd.h"
#include "DataFormats/EgammaCandidates/interface/GsfElectron.h"
#include "DataFormats/EgammaCandidates/interface/GsfElectronFwd.h"

#include "DataFormats/MuonReco/interface/Muon.h"
#include "DataFormats/MuonReco/interface/MuonFwd.h"
#include "DataFormats/MuonReco/interface/MuonMETCorrectionData.h"
#include "DataFormats/TrackReco/interface/Track.h"
#include "DataFormats/VertexReco/interface/Vertex.h"
#include "DataFormats/TrackReco/interface/TrackFwd.h"
#include "DataFormats/METReco/interface/CaloMET.h"
#include "DataFormats/METReco/interface/MET.h"
#include "DataFormats/METReco/interface/PFMET.h"

#include "TrackingTools/TrajectoryState/interface/TrajectoryStateOnSurface.h"
#include "TrackingTools/GeomPropagators/interface/AnalyticalPropagator.h"
#include "MagneticField/Engine/interface/MagneticField.h"
#include "MagneticField/Records/interface/IdealMagneticFieldRecord.h"
#include "Geometry/Records/interface/IdealGeometryRecord.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 "Math/GenVector/VectorUtil.h"
#include "DataFormats/BeamSpot/interface/BeamSpot.h"

#include "DataFormats/ParticleFlowReco/interface/PFLayer.h"
#include "DataFormats/ParticleFlowReco/interface/PFCluster.h"
#include "DataFormats/ParticleFlowReco/interface/PFClusterFwd.h"

#include <cmath>
#include <iostream>
#include "TVector3.h"
#include "TH2.h"
#include "TMath.h"

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

//------------------------------------------------------------------------
// Default Constructer
//----------------------------------
TCMETAlgo::TCMETAlgo() {
  showerRF          = 0;
  response_function = 0;

}


void TCMETAlgo::configure(const edm::ParameterSet& iConfig, int myResponseFunctionType) {
     // get configuration parameters

     usePFClusters_           = iConfig.getParameter<bool>  ("usePFClusters");
     inputTagPFClustersECAL_  = iConfig.getParameter<edm::InputTag>("PFClustersECAL");
     inputTagPFClustersHCAL_  = iConfig.getParameter<edm::InputTag>("PFClustersHCAL");
     inputTagPFClustersHFEM_  = iConfig.getParameter<edm::InputTag>("PFClustersHFEM");
     inputTagPFClustersHFHAD_ = iConfig.getParameter<edm::InputTag>("PFClustersHFHAD");
     
     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");
     vetoDuplicates_         = iConfig.getParameter<bool>     ("vetoDuplicates");
     dupMinPt_               = iConfig.getParameter<double>   ("dupMinPt");
     dupDPhi_                = iConfig.getParameter<double>   ("dupDPhi");
     dupDCotTh_              = iConfig.getParameter<double>   ("dupDCotTh");

     electronVetoCone_       = iConfig.getParameter<bool>  ("electronVetoCone");
     eVetoDeltaR_            = iConfig.getParameter<double>("eVetoDeltaR");
     eVetoDeltaPhi_          = iConfig.getParameter<double>("eVetoDeltaPhi");
     eVetoDeltaCotTheta_     = iConfig.getParameter<double>("eVetoDeltaCotTheta");
     eVetoMinElectronPt_     = iConfig.getParameter<double>("eVetoMinElectronPt");
     correctShowerTracks_    = iConfig.getParameter<bool>  ("correctShowerTracks");
     checkTrackPropagation_  = iConfig.getParameter<bool>  ("checkTrackPropagation");
     usePvtxd0_              = iConfig.getParameter<bool>  ("usePvtxd0");
     nMinOuterHits_          = iConfig.getParameter<int>   ("nMinOuterHits");
     usedeltaRRejection_     = iConfig.getParameter<bool>  ("usedeltaRRejection");
     deltaRShower_           = iConfig.getParameter<double>("deltaRShower");
     radius_                 = iConfig.getParameter<double>("radius");
     zdist_                  = iConfig.getParameter<double>("zdist");
     corner_                 = iConfig.getParameter<double>("corner");
     d0cuta_                 = iConfig.getParameter<double>("d0cuta");
     d0cutb_                 = iConfig.getParameter<double>("d0cutb");
     maxd0cut_               = iConfig.getParameter<double>("maxd0cut");
     maxchi2_tight_          = iConfig.getParameter<double>("chi2_tight_max" );
     minhits_tight_          = iConfig.getParameter<double>("nhits_tight_min");
     maxPtErr_tight_         = iConfig.getParameter<double>("ptErr_tight_max");
     maxTrackAlgo_           = iConfig.getParameter<int>   ("maxTrackAlgo");     

     isCosmics_ = iConfig.getParameter<bool>  ("isCosmics");
     rfType_    = iConfig.getParameter<int>   ("rf_type"  );
     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");
     hOverECut_ = iConfig.getParameter<double>("hOverECut");

     trkQuality_ = iConfig.getParameter<std::vector<int> >("track_quality");
     trkAlgos_   = iConfig.getParameter<std::vector<int> >("track_algos"  );

     // get input collection tags
     muonInputTag_     = iConfig.getParameter<edm::InputTag>("muonInputTag"    );
     metInputTag_      = iConfig.getParameter<edm::InputTag>("metInputTag"     );
     trackInputTag_    = iConfig.getParameter<edm::InputTag>("trackInputTag"   );
     beamSpotInputTag_ = iConfig.getParameter<edm::InputTag>("beamSpotInputTag");
     vertexInputTag_   = iConfig.getParameter<edm::InputTag>("vertexInputTag");

     if( !isCosmics_ )
          electronInputTag_ = iConfig.getParameter<edm::InputTag>("electronInputTag");

     // get input value map tags
     muonDepValueMap_  = iConfig.getParameter<edm::InputTag>("muonDepValueMap" );
     tcmetDepValueMap_ = iConfig.getParameter<edm::InputTag>("tcmetDepValueMap");

     // remember response function
     showerRF          = getResponseFunction_shower();
     response_function = 0;

     if( myResponseFunctionType == 0 )
       response_function = getResponseFunction_noshower();
     else if( myResponseFunctionType == 1 )
       response_function = getResponseFunction_fit();
     else if( myResponseFunctionType == 2 )
       response_function = getResponseFunction_mode();
     


}
//------------------------------------------------------------------------

//------------------------------------------------------------------------
// Default Destructor
//----------------------------------
TCMETAlgo::~TCMETAlgo() {
  delete response_function;
  delete showerRF;
}
//------------------------------------------------------------------------

reco::MET TCMETAlgo::CalculateTCMET(edm::Event& event, const edm::EventSetup& setup )
{ 

     // get input collections
     event.getByLabel( muonInputTag_    , MuonHandle    );
     event.getByLabel( electronInputTag_, ElectronHandle);
     event.getByLabel( metInputTag_     , metHandle     );
     event.getByLabel( trackInputTag_   , TrackHandle   );
     event.getByLabel( beamSpotInputTag_, beamSpotHandle);

     //get vertex collection
     hasValidVertex = false;
     if( usePvtxd0_ ){
       event.getByLabel( vertexInputTag_  , VertexHandle  );
       if( VertexHandle.isValid() ) {
         vertexColl = VertexHandle.product();
         hasValidVertex = isValidVertex();
       } 
     }
     
     if( vetoDuplicates_ ){
       duplicateTracks_.clear();
       findDuplicateTracks();
     }
     
     //get PFCluster collections
     edm::Handle< reco::PFClusterCollection > clustersECAL;
     edm::Handle< reco::PFClusterCollection > clustersHCAL;
     edm::Handle< reco::PFClusterCollection > clustersHFEM;
     edm::Handle< reco::PFClusterCollection > clustersHFHAD;
     
     float pfcmet_x = 0.;
     float pfcmet_y = 0.;
     float pfcsumet = 0.;

     if( usePFClusters_ ){
       bool found = event.getByLabel(inputTagPFClustersECAL_, clustersECAL);      
       
       if(!found )
         edm::LogError("RecoMET")<<" cannot get ECAL clusters: "
                                         <<inputTagPFClustersECAL_<<std::endl;
       
       found = event.getByLabel(inputTagPFClustersHCAL_, clustersHCAL);
       
       if(!found )
         edm::LogError("RecoMET")<<" cannot get HCAL clusters: "
                                         <<inputTagPFClustersHCAL_<<std::endl;
       
       found = event.getByLabel(inputTagPFClustersHFEM_, clustersHFEM);      
       
       if(!found )
         edm::LogError("RecoMET")<<" cannot get HFEM clusters: "
                                         <<inputTagPFClustersHFEM_<<std::endl;
       
       found = event.getByLabel(inputTagPFClustersHFHAD_, clustersHFHAD);      
       
       if(!found )
         edm::LogError("RecoMET")<<" cannot get HFHAD clusters: "
                                         <<inputTagPFClustersHFHAD_<<std::endl;
     
       for (reco::PFClusterCollection::const_iterator it = clustersECAL->begin(); it != clustersECAL->end(); it++){
         
         const math::XYZPoint&  cluster_pos = it->position();
         double et = it->energy() / cosh( cluster_pos.eta() ); 
         
         pfcmet_x  -= et * cos(cluster_pos.phi());
         pfcmet_y  -= et * sin(cluster_pos.phi());
         pfcsumet  += et;
       }
       
       for (reco::PFClusterCollection::const_iterator it = clustersHCAL->begin(); it != clustersHCAL->end(); it++){
         if ( it->layer() == PFLayer::HCAL_BARREL2) continue; //skip HO

         const math::XYZPoint&  cluster_pos = it->position();
         double et = it->energy() / cosh( cluster_pos.eta() ); 
         
         pfcmet_x  -= et * cos(cluster_pos.phi());
         pfcmet_y  -= et * sin(cluster_pos.phi());
         pfcsumet  += et;
       }

       for (reco::PFClusterCollection::const_iterator it = clustersHFHAD->begin(); it != clustersHFHAD->end(); it++){

         const math::XYZPoint&  cluster_pos = it->position();
         double et = it->energy() / cosh( cluster_pos.eta() ); 
       
         pfcmet_x  -= et * cos(cluster_pos.phi());
         pfcmet_y  -= et * sin(cluster_pos.phi());
         pfcsumet  += et;
       }

       for (reco::PFClusterCollection::const_iterator it = clustersHFEM->begin(); it != clustersHFEM->end(); it++){

         const math::XYZPoint&  cluster_pos = it->position();
         double et = it->energy() / cosh( cluster_pos.eta() ); 
       
         pfcmet_x  -= et * cos(cluster_pos.phi());
         pfcmet_y  -= et * sin(cluster_pos.phi());
         pfcsumet  += et;
       }
     }

     // get input value maps
     event.getByLabel( muonDepValueMap_ , muon_data_h );
     event.getByLabel( tcmetDepValueMap_, tcmet_data_h );

     muon_data  = *muon_data_h;
     tcmet_data = *tcmet_data_h;

     unsigned int nMuons  = MuonHandle->size();
     unsigned int nTracks = TrackHandle->size();

     edm::ESHandle<MagneticField> theMagField;
     setup.get<IdealMagneticFieldRecord>().get(theMagField);
     bField = theMagField.product();

    if( usePFClusters_ ){
       //initialize MET, sumEt to PFCluster values
       met_x = pfcmet_x;
       met_y = pfcmet_y;
       sumEt = pfcsumet;
     }
     else{
       //initialize MET, sumEt to caloMET values
       met_x = (metHandle->front()).px();
       met_y = (metHandle->front()).py();
       sumEt = (metHandle->front()).sumEt();
     }

     //calculate tcMET - correct for muons
     for( unsigned int mu_idx = 0; mu_idx < nMuons; mu_idx++ ) {
          const reco::Muon* mu = &(*MuonHandle)[mu_idx];
          reco::TrackRef track;
          reco::MuonRef muref( MuonHandle, mu_idx);
          reco::MuonMETCorrectionData muCorrData = (tcmet_data)[muref];
          int flag = muCorrData.type();

          if( flag == 1 ) {
               if( !mu->isGlobalMuon() ) {
                    edm::LogError("TCMETAlgo") << "This is not a global muon, but is flagged as one by the TCMET ValueMap.  "
                                               << "Not correcting for this muon.  Check your collection!!!"
                                               << std::endl;
                    continue;
               }

               track = mu->globalTrack();
               correctMETforMuon( track, mu_idx );
               correctSumEtForMuon( track, mu_idx );
          }
          else if( flag == 2 ) {
               if( !mu->isTrackerMuon() ) {
                    edm::LogError("TCMETAlgo") << "This is not a tracker muon, but is flagged as one by the TCMET ValueMap.  "
                                               << "Not correcting for this muon.  Check your collection!!!"
                                               << std::endl;
                    continue;
               }

               track = mu->innerTrack();
               correctMETforMuon( track, mu_idx );
               correctSumEtForMuon( track, mu_idx );
          }
          else if( flag == 3 ) {
               edm::LogVerbatim("TCMETAlgo") << "Are you sure you want to correct using the StandAlone fit??" << std::endl;
               if( !mu->isStandAloneMuon() ) {
                    edm::LogError("TCMETAlgo") << "This is not a standalone muon, but is flagged as one by the TCMET ValueMap.  "
                                               << "Not correcting for this muon.  Check your collection!!!"
                                               << std::endl;
                    continue;
               }

               track = mu->outerTrack();
               correctMETforMuon( track, mu_idx );
               correctSumEtForMuon( track, mu_idx );      
          }
          else if( flag == 4 ){
               if( mu->isGlobalMuon() ) track = mu->innerTrack();
               else if( mu->isTrackerMuon() ) track = mu->innerTrack();
               else if( mu->isCaloMuon() ) track = mu->innerTrack();
               else {
                    edm::LogError("TCMETAlgo") << "You are attempting to correct a muon that does not have an associated track as a pion!"
                                               << "Check your value map!"
                                               << std::endl;
                    continue;
               }
               
               const TVector3 outerTrackPosition = propagateTrack( track );
               correctMETforTrack( track , response_function , outerTrackPosition);
               correctSumEtForTrack( track , response_function , outerTrackPosition);
          }
          else if( flag == 5 ) {
               if( !mu->isGlobalMuon() && !mu->isTrackerMuon() && mu->isStandAloneMuon() )
                    edm::LogVerbatim("TCMETAlgo") << "Are you sure you want to correct using the StandAlone fit??" << std::endl;

               correctMETforMuon( mu_idx );
               correctSumEtForMuon( mu_idx );
          }
          else if( flag == 0 ) continue;
          else
               edm::LogError("TCMETAlgo") << "Invalid muon flag from TCMET ValueMap.  Check your value map." << std::endl;
    
     }
     
     //find tracks which satisfy track quality cuts and nExpectedOuterHits cut
     std::vector<int> goodShowerTracks;
     if(usedeltaRRejection_){
       findGoodShowerTracks(goodShowerTracks);
     }
  
     // calculate tcMET - correct for pions
     for( unsigned int trk_idx = 0; trk_idx < nTracks; trk_idx++ ) {

          if( isMuon( trk_idx ) ) continue;

          if( !isCosmics_ )
               if( isElectron( trk_idx ) ) continue;

          reco::TrackRef trkref( TrackHandle, trk_idx);

          if( !isGoodTrack( trkref , trk_idx ) ) continue;

          if( electronVetoCone_ && closeToElectron( trkref ) )
            continue;

          const TVector3 outerTrackPosition = propagateTrack( trkref );  //propagate track from vertex to calorimeter face

          if(correctShowerTracks_){

            if(usedeltaRRejection_){
              if(nearGoodShowerTrack( trkref , goodShowerTracks)) continue;
            }

            //apply separate RF for showering tracks
            if(nExpectedOuterHits( trkref ) >= nMinOuterHits_){
              correctMETforTrack( trkref , showerRF , outerTrackPosition);
              correctSumEtForTrack( trkref , showerRF , outerTrackPosition);
            }
            
            else{
              correctMETforTrack( trkref , response_function , outerTrackPosition);
              correctSumEtForTrack( trkref , response_function , outerTrackPosition);
            }

          }else{
            correctMETforTrack( trkref , response_function , outerTrackPosition);
            correctSumEtForTrack( trkref , response_function , outerTrackPosition);
          }
     }

     //fill tcMET object
     CommonMETData TCMETData;
     TCMETData.mex   = met_x;
     TCMETData.mey   = met_y;
     TCMETData.mez   = 0.0;
     TCMETData.met   = TMath::Sqrt( met_x * met_x + met_y * met_y );
     TCMETData.sumet = sumEt;
     TCMETData.phi   = atan2( met_y, met_x ); 

     math::XYZTLorentzVector p4( TCMETData.mex , TCMETData.mey , 0, TCMETData.met);
     math::XYZPointD vtx(0,0,0);
     reco::MET tcmet(TCMETData.sumet, p4, vtx);
     return tcmet;
}

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

void TCMETAlgo::findDuplicateTracks(){

  unsigned int nTracks = TrackHandle->size();

  for( unsigned int trk_idx = 0; trk_idx < nTracks; trk_idx++ ) {
    
    if( isMuon( trk_idx ) )                    continue;
    if( !isCosmics_ && isElectron( trk_idx ) ) continue;

    reco::TrackRef trkref( TrackHandle, trk_idx );
    if( trkref->pt() < dupMinPt_ ) continue;

    for( unsigned int trk_idx2 = trk_idx + 1 ; trk_idx2 < nTracks; trk_idx2++ ) {
    
      if( isMuon( trk_idx2 ) )                    continue;
      if( !isCosmics_ && isElectron( trk_idx2 ) ) continue;
      
      reco::TrackRef trkref2( TrackHandle, trk_idx2 );
      if( trkref->charge() * trkref2->charge() < 0 ) continue;
      if( trkref2->pt() < dupMinPt_ )                continue;

      float dphi = fabs( trkref->phi() - trkref2->phi() );
      if( dphi > TMath::Pi() ) dphi = TMath::TwoPi() - dphi;

      float dcotth = fabs( 1./tan( trkref->theta() ) - 1./tan( trkref2->theta() ) );

      if( dphi   > dupDPhi_    ) continue;
      if( dcotth > dupDCotTh_  ) continue;

      int iVeto = vetoTrack( trk_idx , trk_idx2 );
      duplicateTracks_.push_back( iVeto );

    }
  }
}

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

int TCMETAlgo::vetoTrack( int i1 , int i2 ){

  //given 2 tracks, decide which one to veto
  reco::TrackRef t1( TrackHandle, i1 );
  reco::TrackRef t2( TrackHandle, i2 );

  if     ( t1->numberOfValidHits() < t2->numberOfValidHits() )   return i1;
  else if( t1->numberOfValidHits() > t2->numberOfValidHits() )   return i2;
  else if( t1->chi2() / t1->ndof() > t2->chi2() / t2->ndof() )   return i1;
  else if( t1->chi2() / t1->ndof() < t2->chi2() / t2->ndof() )   return i2;
  else if( t1->ptError() > t2->ptError() )                       return i1;
  else if( t1->ptError() < t2->ptError() )                       return i2;
  else                                                           return i1; 

}

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

bool TCMETAlgo::isValidVertex(){

  if( vertexColl->begin()->isFake()                ) return false;
  if( vertexColl->begin()->ndof() < vertexNdof_    ) return false;
  if( fabs( vertexColl->begin()->z() ) > vertexZ_  ) return false;
  if( sqrt( pow( vertexColl->begin()->x() , 2 ) + pow( vertexColl->begin()->y() , 2 ) ) > vertexRho_ ) return false;

  return true;

}

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

bool TCMETAlgo::closeToElectron( const reco::TrackRef track ){
 
  float trk_eta   = track->eta();
  float trk_phi   = track->phi();
  LorentzVector tk_p4(track->px(), track->py(),track->pz(), track->p());

  for(reco::GsfElectronCollection::const_iterator electron_it = ElectronHandle->begin(); 
      electron_it != ElectronHandle->end(); ++electron_it) {
    
    if( electron_it->hadronicOverEm() > hOverECut_ ) continue; 

    reco::TrackRef el_track = electron_it->closestCtfTrackRef();      

    if(!el_track.isNonnull()) continue;
 
    if( el_track->pt() < eVetoMinElectronPt_ ) continue;

    LorentzVector el_p4(el_track->px(), el_track->py(), el_track->pz(), el_track->p());

    float deltaPhi   = fabs( el_track->phi() - trk_phi );
    if( deltaPhi > TMath::Pi() ) deltaPhi = TMath::TwoPi() - deltaPhi;  
    float deltaEta   = el_track->eta() - trk_eta;
    float deltaR     = sqrt(deltaPhi * deltaPhi + deltaEta * deltaEta);
    float deltaCotTh = 1. / tan( el_p4.theta() ) - 1. / tan( tk_p4.theta() );
            
    if( deltaPhi < eVetoDeltaPhi_ && deltaCotTh < eVetoDeltaCotTheta_ && deltaR < eVetoDeltaR_) return true;
    
  }

  return false;
}

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

bool TCMETAlgo::nearGoodShowerTrack( const reco::TrackRef track , std::vector<int> goodShowerTracks ){
  
  //checks if 'track' is within dR < deltaRShower_ of any good shower tracks
  float eta1 = track->eta();
  float phi1 = track->phi();
  
  for(unsigned int itrk = 0 ; itrk < goodShowerTracks.size() ; itrk++){

    reco::TrackRef trkref( TrackHandle, itrk);
    float eta2 = trkref->eta();
    float phi2 = trkref->phi();

    float dR = sqrt(pow(eta1-eta2,2) + pow(phi1-phi2,2));
    if(dR < deltaRShower_) return true;

  }

  return false;
}

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

void TCMETAlgo::findGoodShowerTracks(std::vector<int>& goodShowerTracks){

  //stores the indices of tracks which pass quality selection and
  //nMinOuterHits cut in goodShowerTracks vector
  for( unsigned int trk_idx = 0; trk_idx < TrackHandle->size() ; trk_idx++ ) {
    
    if( isMuon( trk_idx ) )    
      continue;
    
    if( !isCosmics_ ){
      if( isElectron( trk_idx ) ) 
        continue;
    }
    
    reco::TrackRef trkref( TrackHandle, trk_idx);
    
    if( !isGoodTrack( trkref , trk_idx ) ) 
      continue;
    
    if(nExpectedOuterHits( trkref ) < nMinOuterHits_)
      continue;
    
    goodShowerTracks.push_back(trk_idx);

  }
}

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

int TCMETAlgo::nExpectedInnerHits(const reco::TrackRef track){
  const reco::HitPattern& p_inner = track->trackerExpectedHitsInner();
  return p_inner.numberOfHits();
}

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

int TCMETAlgo::nExpectedOuterHits(const reco::TrackRef track){
  const reco::HitPattern& p_outer = track->trackerExpectedHitsOuter();
  return p_outer.numberOfHits();
}

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

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

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

//determines if track is matched to a muon
bool TCMETAlgo::isMuon( unsigned int trk_idx ) {

     for(reco::MuonCollection::const_iterator muon_it = MuonHandle->begin(); muon_it != MuonHandle->end(); ++muon_it) {

          reco::TrackRef mu_track = muon_it->innerTrack();

          unsigned int mu_idx = mu_track.isNonnull() ? mu_track.key() : 99999;
    
          if( mu_idx == trk_idx ) return true;
     }

     return false;
}

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

//determines if track is matched to an "electron-like" object
bool TCMETAlgo::isElectron( unsigned int trk_idx ) {

     for(reco::GsfElectronCollection::const_iterator electron_it = ElectronHandle->begin(); electron_it != ElectronHandle->end(); ++electron_it) {

          reco::TrackRef el_track = electron_it->closestCtfTrackRef();

          unsigned int ele_idx = el_track.isNonnull() ? el_track.key() : 99999;

          if( ele_idx == trk_idx ) {
               if( electron_it->hadronicOverEm() < hOverECut_ ) 
                    return true;
          }
     }

     return false;
}

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

//determines if track is "good" - i.e. passes quality and kinematic cuts
bool TCMETAlgo::isGoodTrack( const reco::TrackRef track , int trk_idx) {
  
     double d0 = 9999.;

     if( hasValidVertex ){
        //get d0 corrected for primary vertex
       
       const Point pvtx = Point(vertexColl->begin()->x(),
                                vertexColl->begin()->y(), 
                                vertexColl->begin()->z());
       
       double dz = track->dz( pvtx );
       
       if( fabs( dz ) < vertexMaxDZ_ ){
         
         //get d0 corrected for pvtx
         d0 = -1 * track->dxy( pvtx );
      
       }
       else{

         // get d0 corrected for beam spot
         bool haveBeamSpot = true;
         if( !beamSpotHandle.isValid() ) haveBeamSpot = false;
         
         Point bspot = haveBeamSpot ? beamSpotHandle->position() : Point(0,0,0);
         d0 = -1 * track->dxy( bspot );
       }
       
     }else{
       
       // get d0 corrected for beam spot
       bool haveBeamSpot = true;
       if( !beamSpotHandle.isValid() ) haveBeamSpot = false;
       
       Point bspot = haveBeamSpot ? beamSpotHandle->position() : Point(0,0,0);
       d0 = -1 * track->dxy( bspot );
     }
     
     if( track->algo() < maxTrackAlgo_ ){
       //1st 4 tracking iterations (pT-dependent d0 cut + nlayers cut)
       
       float d0cut = sqrt(pow(d0cuta_,2) + pow(d0cutb_/track->pt(),2)); 
       if(d0cut > maxd0cut_) d0cut = maxd0cut_;
       
       if( fabs( d0 ) > d0cut )          return false;
       if( nLayers( track ) < nLayers_ ) return false;
    
     }
     else{
       //last 2 tracking iterations (tighten chi2, nhits, pt error, nlayers cuts)
     
       if( track->normalizedChi2() > maxchi2_tight_ )             return false;
       if( track->numberOfValidHits() < minhits_tight_ )          return false;
       if( (track->ptError() / track->pt()) > maxPtErr_tight_ )   return false;
       if( nLayers( track ) < nLayersTight_ )                     return false;

     }

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

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

     if( !( ( track->qualityMask() & cut ) == cut ) ) return false;

     bool isGoodAlgo = false;
     if( trkAlgos_.size() == 0 ) isGoodAlgo = true;
     for( unsigned int i = 0; i < trkAlgos_.size(); i++ ) {
       
          if( track->algo() == trkAlgos_.at(i) ) isGoodAlgo = true;
     }

     if( !isGoodAlgo ) return false;
         
     if( vetoDuplicates_ ) {
       for( unsigned int iDup = 0 ; iDup < duplicateTracks_.size() ; iDup++ ){
         if( trk_idx == duplicateTracks_.at( iDup ) ) return false;
       } 
     }   

     return true;
}

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

//correct MET for muon

void TCMETAlgo::correctMETforMuon( const reco::TrackRef track, const unsigned int index ) {
     reco::MuonRef muref( MuonHandle, index);
     reco::MuonMETCorrectionData muCorrData = (muon_data)[muref];

     double delx = muCorrData.corrX();
     double dely = muCorrData.corrY();

     met_x -= ( track->px() - delx );
     met_y -= ( track->py() - dely );
}

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

void TCMETAlgo::correctMETforMuon( const unsigned int index ) {
     reco::MuonRef muref( MuonHandle, index);
     reco::MuonMETCorrectionData muCorrData = (muon_data)[muref];

     double delx = muCorrData.corrX();
     double dely = muCorrData.corrY();

     const reco::Muon* muon = &(*MuonHandle)[index];

     met_x -= ( muon->px() - delx );
     met_y -= ( muon->py() - dely );
}

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

//correct sumEt for muon

void TCMETAlgo::correctSumEtForMuon( const reco::TrackRef track, const unsigned int index ) {
     reco::MuonRef muref( MuonHandle, index);
     reco::MuonMETCorrectionData muCorrData = (muon_data)[muref];

     double delx = muCorrData.corrX();
     double dely = muCorrData.corrY();

     sumEt += ( track->pt() - TMath::Sqrt( delx * delx + dely * dely ) );
}

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

void TCMETAlgo::correctSumEtForMuon( const unsigned int index ) {
     reco::MuonRef muref( MuonHandle, index);
     reco::MuonMETCorrectionData muCorrData = (muon_data)[muref];

     double delx = muCorrData.corrX();
     double dely = muCorrData.corrY();

     const reco::Muon* muon = &(*MuonHandle)[index];

     sumEt += ( muon->pt() - TMath::Sqrt( delx * delx + dely * dely ) );
}

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

//correct MET for track

void TCMETAlgo::correctMETforTrack( const reco::TrackRef track , TH2D* rf , const TVector3 outerTrackPosition) {

     if( track->pt() < minpt_ ) {

          met_x -= track->pt() * cos( track->phi() );
          met_y -= track->pt() * sin( track->phi() );
     }

     else {
       //const TVector3 outerTrackPosition = propagateTrack( track );  //propagate track from vertex to calorimeter face
          
       if(checkTrackPropagation_ && outerTrackPosition.Theta() < -9.99 ){
         //fail track propagation check
       }
       else{
         
          int bin_index = rf->FindBin( track->eta(), track->pt() );  
          double fracTrackEnergy = rf->GetBinContent( bin_index );  //get correction factor from response function
         
          met_x += ( fracTrackEnergy * track->p() * sin( outerTrackPosition.Theta() ) * cos( outerTrackPosition.Phi() ) //remove expected amount of energy track deposited in calorimeter
                     - track->pt() * cos( track->phi() ) );  //add track at vertex

          met_y += ( fracTrackEnergy * track->p() * sin( outerTrackPosition.Theta() ) * sin( outerTrackPosition.Phi() ) //remove expected amount of energy track deposited in calorimeter
                     - track->pt() * sin( track->phi() ) );  //add track at vertex
       } 
     } 
     
}

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

//correct sumEt for track

void TCMETAlgo::correctSumEtForTrack( const reco::TrackRef track  , TH2D* rf , const TVector3 outerTrackPosition) {

     if( track->pt() < minpt_ ) {
          sumEt += track->pt();
     }

     else {

          if(checkTrackPropagation_ && outerTrackPosition.Theta() < -9.99 ){
            //fail track propagation check
          }
          else{
            int bin_index = rf->FindBin( track->eta(), track->pt() );
            double fracTrackEnergy = rf->GetBinContent( bin_index );  //get correction factor from response function
            
            sumEt += ( 1 - fracTrackEnergy ) * track->pt();
          }
     }
}

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

//propagate track from vertex to calorimeter face

TVector3 TCMETAlgo::propagateTrack( const reco::TrackRef track ) {

     TVector3 outerTrkPosition;

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

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

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

     const float zdist = zdist_; //314.;

     const float radius = radius_; //130.;

     const float corner = 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->eta() < -corner ) {
          tsos = myAP.propagate( fts, *lendcap);
     }
     else if( fabs(track->eta()) < corner ) {
          tsos = myAP.propagate( fts, *barrel);
     }
     else if( track->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 shower track-----

TH2D* TCMETAlgo::getResponseFunction_shower() {


  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","shower RF (fit)",52, xAxis1,28, yAxis1);
  hrf->SetBinContent(163,0.4499661);
  hrf->SetBinContent(164,0.5115394);
  hrf->SetBinContent(165,0.5748767);
  hrf->SetBinContent(166,0.6531988);
  hrf->SetBinContent(167,0.6228076);
  hrf->SetBinContent(168,0.54419);
  hrf->SetBinContent(169,0.5556401);
  hrf->SetBinContent(170,0.5216789);
  hrf->SetBinContent(171,0.3942387);
  hrf->SetBinContent(172,0.3166006);
  hrf->SetBinContent(173,0.2794519);
  hrf->SetBinContent(174,0.2712919);
  hrf->SetBinContent(175,0.2809297);
  hrf->SetBinContent(176,3.501783e-12);
  hrf->SetBinContent(177,1.395287e-14);
  hrf->SetBinContent(178,1.002659e-14);
  hrf->SetBinContent(179,1.996966e-13);
  hrf->SetBinContent(180,1.185354e-12);
  hrf->SetBinContent(181,0.1562845);
  hrf->SetBinContent(182,0.3277632);
  hrf->SetBinContent(183,9.387774e-12);
  hrf->SetBinContent(184,1.936981e-15);
  hrf->SetBinContent(185,1.395151e-15);
  hrf->SetBinContent(186,6.578116e-13);
  hrf->SetBinContent(187,3.868433e-16);
  hrf->SetBinContent(188,4.808265e-13);
  hrf->SetBinContent(189,1.502861e-11);
  hrf->SetBinContent(190,9.644046e-12);
  hrf->SetBinContent(191,1.371502e-10);
  hrf->SetBinContent(192,1.107704e-13);
  hrf->SetBinContent(193,4.781223e-15);
  hrf->SetBinContent(194,2.42137e-12);
  hrf->SetBinContent(195,7.183598e-15);
  hrf->SetBinContent(196,7.702724e-11);
  hrf->SetBinContent(197,7.081141e-15);
  hrf->SetBinContent(198,4.414546e-15);
  hrf->SetBinContent(199,6.467266e-14);
  hrf->SetBinContent(200,4.396606e-13);
  hrf->SetBinContent(201,1.255334e-13);
  hrf->SetBinContent(202,0.2490428);
  hrf->SetBinContent(203,0.1774015);
  hrf->SetBinContent(204,0.03958736);
  hrf->SetBinContent(205,0.173943);
  hrf->SetBinContent(206,2.754122e-09);
  hrf->SetBinContent(207,0.3376317);
  hrf->SetBinContent(208,0.379734);
  hrf->SetBinContent(209,0.4411897);
  hrf->SetBinContent(210,0.4646802);
  hrf->SetBinContent(211,0.4630073);
  hrf->SetBinContent(212,0.4258874);
  hrf->SetBinContent(213,0.4351387);
  hrf->SetBinContent(214,0.3997094);
  hrf->SetBinContent(217,0.4259718);
  hrf->SetBinContent(218,0.4852031);
  hrf->SetBinContent(219,0.5131704);
  hrf->SetBinContent(220,0.5269414);
  hrf->SetBinContent(221,0.5275139);
  hrf->SetBinContent(222,0.4957667);
  hrf->SetBinContent(223,0.4246427);
  hrf->SetBinContent(224,0.3784586);
  hrf->SetBinContent(225,0.3247786);
  hrf->SetBinContent(226,0.2571901);
  hrf->SetBinContent(227,0.1693018);
  hrf->SetBinContent(228,2.160257e-12);
  hrf->SetBinContent(229,8.770899e-13);
  hrf->SetBinContent(230,5.012884e-13);
  hrf->SetBinContent(231,2.994393e-14);
  hrf->SetBinContent(232,3.153311e-11);
  hrf->SetBinContent(233,0.2774436);
  hrf->SetBinContent(234,0.2977051);
  hrf->SetBinContent(235,4.19017e-15);
  hrf->SetBinContent(236,7.045583e-13);
  hrf->SetBinContent(237,7.671467e-13);
  hrf->SetBinContent(238,6.307742e-14);
  hrf->SetBinContent(239,1.032541e-13);
  hrf->SetBinContent(240,6.584719e-11);
  hrf->SetBinContent(241,1.218903e-12);
  hrf->SetBinContent(242,1.369637e-11);
  hrf->SetBinContent(243,8.558079e-14);
  hrf->SetBinContent(244,4.513987e-13);
  hrf->SetBinContent(245,2.556831e-10);
  hrf->SetBinContent(246,1.420917e-11);
  hrf->SetBinContent(247,6.229907e-14);
  hrf->SetBinContent(248,1.40826e-12);
  hrf->SetBinContent(249,1.143873e-12);
  hrf->SetBinContent(250,6.677059e-16);
  hrf->SetBinContent(251,3.113288e-12);
  hrf->SetBinContent(252,0.2333517);
  hrf->SetBinContent(253,0.1787967);
  hrf->SetBinContent(254,5.41192e-13);
  hrf->SetBinContent(255,6.694948e-17);
  hrf->SetBinContent(256,2.782238e-13);
  hrf->SetBinContent(257,3.274193e-14);
  hrf->SetBinContent(258,5.731716e-14);
  hrf->SetBinContent(259,1.739033e-13);
  hrf->SetBinContent(260,0.1770892);
  hrf->SetBinContent(261,0.1898742);
  hrf->SetBinContent(262,0.3387461);
  hrf->SetBinContent(263,0.3859385);
  hrf->SetBinContent(264,0.439089);
  hrf->SetBinContent(265,0.4233858);
  hrf->SetBinContent(266,0.4308124);
  hrf->SetBinContent(267,0.4063357);
  hrf->SetBinContent(268,0.407559);
  hrf->SetBinContent(271,0.4507765);
  hrf->SetBinContent(272,0.4278911);
  hrf->SetBinContent(273,0.447516);
  hrf->SetBinContent(274,0.4947385);
  hrf->SetBinContent(275,0.4755806);
  hrf->SetBinContent(276,0.3945268);
  hrf->SetBinContent(277,0.4245627);
  hrf->SetBinContent(278,0.3956718);
  hrf->SetBinContent(279,0.2930262);
  hrf->SetBinContent(280,0.282435);
  hrf->SetBinContent(281,0.1969091);
  hrf->SetBinContent(282,2.725097e-10);
  hrf->SetBinContent(283,1.408023e-12);
  hrf->SetBinContent(284,1.613806e-12);
  hrf->SetBinContent(285,0.06278097);
  hrf->SetBinContent(286,2.576515e-13);
  hrf->SetBinContent(287,2.583938e-11);
  hrf->SetBinContent(288,0.02207314);
  hrf->SetBinContent(289,4.17668e-11);
  hrf->SetBinContent(290,1.201223e-13);
  hrf->SetBinContent(291,0.202147);
  hrf->SetBinContent(292,0.213694);
  hrf->SetBinContent(293,0.3833649);
  hrf->SetBinContent(294,0.3896363);
  hrf->SetBinContent(295,0.4015322);
  hrf->SetBinContent(296,0.06830335);
  hrf->SetBinContent(297,0.3644076);
  hrf->SetBinContent(298,0.3335945);
  hrf->SetBinContent(299,0.1969689);
  hrf->SetBinContent(300,0.2202647);
  hrf->SetBinContent(301,0.2408156);
  hrf->SetBinContent(302,0.08467747);
  hrf->SetBinContent(303,0.1732237);
  hrf->SetBinContent(304,2.88671e-12);
  hrf->SetBinContent(305,1.474949e-15);
  hrf->SetBinContent(306,3.611305e-13);
  hrf->SetBinContent(307,7.968386e-12);
  hrf->SetBinContent(308,0.07609402);
  hrf->SetBinContent(309,2.35158e-15);
  hrf->SetBinContent(310,3.144875e-14);
  hrf->SetBinContent(311,7.413513e-11);
  hrf->SetBinContent(312,3.648529e-10);
  hrf->SetBinContent(313,0.161564);
  hrf->SetBinContent(314,0.1703132);
  hrf->SetBinContent(315,0.2463829);
  hrf->SetBinContent(316,0.2828567);
  hrf->SetBinContent(317,0.3274342);
  hrf->SetBinContent(318,0.3545384);
  hrf->SetBinContent(319,0.3461392);
  hrf->SetBinContent(320,0.383806);
  hrf->SetBinContent(321,0.4001317);
  hrf->SetBinContent(322,0.3859067);
  hrf->SetBinContent(325,0.4965547);
  hrf->SetBinContent(326,0.4298636);
  hrf->SetBinContent(327,0.4675876);
  hrf->SetBinContent(328,0.4448023);
  hrf->SetBinContent(329,0.404866);
  hrf->SetBinContent(330,0.3958093);
  hrf->SetBinContent(331,0.3955818);
  hrf->SetBinContent(332,0.4272344);
  hrf->SetBinContent(333,0.3596729);
  hrf->SetBinContent(334,0.3546307);
  hrf->SetBinContent(335,0.3180164);
  hrf->SetBinContent(336,0.2714837);
  hrf->SetBinContent(337,0.248644);
  hrf->SetBinContent(338,0.2589674);
  hrf->SetBinContent(339,0.2311552);
  hrf->SetBinContent(340,0.2332692);
  hrf->SetBinContent(341,0.2837152);
  hrf->SetBinContent(342,0.2119901);
  hrf->SetBinContent(343,0.290872);
  hrf->SetBinContent(344,0.2252947);
  hrf->SetBinContent(345,0.3002172);
  hrf->SetBinContent(346,0.2519063);
  hrf->SetBinContent(347,0.3656891);
  hrf->SetBinContent(348,0.366923);
  hrf->SetBinContent(349,0.3425266);
  hrf->SetBinContent(350,0.3963153);
  hrf->SetBinContent(351,0.4658033);
  hrf->SetBinContent(352,0.2195605);
  hrf->SetBinContent(353,0.3869674);
  hrf->SetBinContent(354,0.3218271);
  hrf->SetBinContent(355,0.287984);
  hrf->SetBinContent(356,0.2912856);
  hrf->SetBinContent(357,0.2681426);
  hrf->SetBinContent(358,0.04988411);
  hrf->SetBinContent(359,0.2593921);
  hrf->SetBinContent(360,0.2092704);
  hrf->SetBinContent(361,0.2379719);
  hrf->SetBinContent(362,0.3087997);
  hrf->SetBinContent(363,0.2041179);
  hrf->SetBinContent(364,0.1946624);
  hrf->SetBinContent(365,0.2187801);
  hrf->SetBinContent(366,0.1256377);
  hrf->SetBinContent(367,0.2779986);
  hrf->SetBinContent(368,0.2988263);
  hrf->SetBinContent(369,0.2804917);
  hrf->SetBinContent(370,0.2762815);
  hrf->SetBinContent(371,0.3480896);
  hrf->SetBinContent(372,0.3402267);
  hrf->SetBinContent(373,0.3655252);
  hrf->SetBinContent(374,0.4143132);
  hrf->SetBinContent(375,0.4424044);
  hrf->SetBinContent(376,0.4635657);
  hrf->SetBinContent(379,0.5328001);
  hrf->SetBinContent(380,0.5040566);
  hrf->SetBinContent(381,0.4762677);
  hrf->SetBinContent(382,0.4729804);
  hrf->SetBinContent(383,0.4241441);
  hrf->SetBinContent(384,0.3924028);
  hrf->SetBinContent(385,0.3985717);
  hrf->SetBinContent(386,0.3816867);
  hrf->SetBinContent(387,0.3967448);
  hrf->SetBinContent(388,0.3603249);
  hrf->SetBinContent(389,0.3489972);
  hrf->SetBinContent(390,0.3275993);
  hrf->SetBinContent(391,0.3116674);
  hrf->SetBinContent(392,0.3572989);
  hrf->SetBinContent(393,0.3118418);
  hrf->SetBinContent(394,0.3412188);
  hrf->SetBinContent(395,0.3356509);
  hrf->SetBinContent(396,0.3173708);
  hrf->SetBinContent(397,0.328909);
  hrf->SetBinContent(398,0.399799);
  hrf->SetBinContent(399,0.311187);
  hrf->SetBinContent(400,0.4324506);
  hrf->SetBinContent(401,0.44069);
  hrf->SetBinContent(402,0.393832);
  hrf->SetBinContent(403,0.456211);
  hrf->SetBinContent(404,0.3807082);
  hrf->SetBinContent(405,0.4484331);
  hrf->SetBinContent(406,0.4281936);
  hrf->SetBinContent(407,0.4100697);
  hrf->SetBinContent(408,0.372774);
  hrf->SetBinContent(409,0.3635768);
  hrf->SetBinContent(410,0.4071924);
  hrf->SetBinContent(411,0.3974379);
  hrf->SetBinContent(412,0.2703223);
  hrf->SetBinContent(413,0.2532525);
  hrf->SetBinContent(414,0.3434703);
  hrf->SetBinContent(415,0.3486526);
  hrf->SetBinContent(416,0.427386);
  hrf->SetBinContent(417,0.3239493);
  hrf->SetBinContent(418,0.2804846);
  hrf->SetBinContent(419,0.2903942);
  hrf->SetBinContent(420,0.3247145);
  hrf->SetBinContent(421,0.3359192);
  hrf->SetBinContent(422,0.3475888);
  hrf->SetBinContent(423,0.3163865);
  hrf->SetBinContent(424,0.3598666);
  hrf->SetBinContent(425,0.3568181);
  hrf->SetBinContent(426,0.4099707);
  hrf->SetBinContent(427,0.4081352);
  hrf->SetBinContent(428,0.4393944);
  hrf->SetBinContent(429,0.4858226);
  hrf->SetBinContent(430,0.5145534);
  hrf->SetBinContent(433,0.5637426);
  hrf->SetBinContent(434,0.5091262);
  hrf->SetBinContent(435,0.5162247);
  hrf->SetBinContent(436,0.4999508);
  hrf->SetBinContent(437,0.4846284);
  hrf->SetBinContent(438,0.4485746);
  hrf->SetBinContent(439,0.4452571);
  hrf->SetBinContent(440,0.4383303);
  hrf->SetBinContent(441,0.4147619);
  hrf->SetBinContent(442,0.3845302);
  hrf->SetBinContent(443,0.3643234);
  hrf->SetBinContent(444,0.3162651);
  hrf->SetBinContent(445,0.3629169);
  hrf->SetBinContent(446,0.3550237);
  hrf->SetBinContent(447,0.3773867);
  hrf->SetBinContent(448,0.3870859);
  hrf->SetBinContent(449,0.4489362);
  hrf->SetBinContent(450,0.4199947);
  hrf->SetBinContent(451,0.3942634);
  hrf->SetBinContent(452,0.4190169);
  hrf->SetBinContent(453,0.4352544);
  hrf->SetBinContent(454,0.5414081);
  hrf->SetBinContent(455,0.4886461);
  hrf->SetBinContent(456,0.491399);
  hrf->SetBinContent(457,0.4949853);
  hrf->SetBinContent(458,0.4736267);
  hrf->SetBinContent(459,0.4950338);
  hrf->SetBinContent(460,0.4496278);
  hrf->SetBinContent(461,0.3453094);
  hrf->SetBinContent(462,0.4956175);
  hrf->SetBinContent(463,0.471592);
  hrf->SetBinContent(464,0.4388095);
  hrf->SetBinContent(465,0.4260533);
  hrf->SetBinContent(466,0.4375692);
  hrf->SetBinContent(467,0.3561876);
  hrf->SetBinContent(468,0.3865653);
  hrf->SetBinContent(469,0.4240963);
  hrf->SetBinContent(470,0.4478125);
  hrf->SetBinContent(471,0.3761102);
  hrf->SetBinContent(472,0.3078025);
  hrf->SetBinContent(473,0.3128132);
  hrf->SetBinContent(474,0.3092445);
  hrf->SetBinContent(475,0.3537644);
  hrf->SetBinContent(476,0.3810261);
  hrf->SetBinContent(477,0.3454433);
  hrf->SetBinContent(478,0.3760064);
  hrf->SetBinContent(479,0.3942058);
  hrf->SetBinContent(480,0.3767672);
  hrf->SetBinContent(481,0.4661797);
  hrf->SetBinContent(482,0.496105);
  hrf->SetBinContent(483,0.5421373);
  hrf->SetBinContent(484,0.5835976);
  hrf->SetBinContent(487,0.6251767);
  hrf->SetBinContent(488,0.5533592);
  hrf->SetBinContent(489,0.5539129);
  hrf->SetBinContent(490,0.5571011);
  hrf->SetBinContent(491,0.461241);
  hrf->SetBinContent(492,0.4907266);
  hrf->SetBinContent(493,0.4790399);
  hrf->SetBinContent(494,0.4644649);
  hrf->SetBinContent(495,0.4707908);
  hrf->SetBinContent(496,0.4255725);
  hrf->SetBinContent(497,0.3789675);
  hrf->SetBinContent(498,0.3281609);
  hrf->SetBinContent(499,0.3849);
  hrf->SetBinContent(500,0.396543);
  hrf->SetBinContent(501,0.4355485);
  hrf->SetBinContent(502,0.4392651);
  hrf->SetBinContent(503,0.4460491);
  hrf->SetBinContent(504,0.4662225);
  hrf->SetBinContent(505,0.4714942);
  hrf->SetBinContent(506,0.4849604);
  hrf->SetBinContent(507,0.5304947);
  hrf->SetBinContent(508,0.4402863);
  hrf->SetBinContent(509,0.4548508);
  hrf->SetBinContent(510,0.5050853);
  hrf->SetBinContent(511,0.6225156);
  hrf->SetBinContent(512,0.5070591);
  hrf->SetBinContent(513,0.5783269);
  hrf->SetBinContent(514,0.4485723);
  hrf->SetBinContent(515,0.4288994);
  hrf->SetBinContent(516,0.5294365);
  hrf->SetBinContent(517,0.4040891);
  hrf->SetBinContent(518,0.45381);
  hrf->SetBinContent(519,0.4817017);
  hrf->SetBinContent(520,0.4337503);
  hrf->SetBinContent(521,0.4618663);
  hrf->SetBinContent(522,0.4487967);
  hrf->SetBinContent(523,0.4660794);
  hrf->SetBinContent(524,0.4697885);
  hrf->SetBinContent(525,0.3807916);
  hrf->SetBinContent(526,0.3590573);
  hrf->SetBinContent(527,0.3666168);
  hrf->SetBinContent(528,0.3436687);
  hrf->SetBinContent(529,0.4094553);
  hrf->SetBinContent(530,0.4075274);
  hrf->SetBinContent(531,0.4259284);
  hrf->SetBinContent(532,0.3687154);
  hrf->SetBinContent(533,0.4227276);
  hrf->SetBinContent(534,0.4622007);
  hrf->SetBinContent(535,0.5158547);
  hrf->SetBinContent(536,0.5761781);
  hrf->SetBinContent(537,0.5306279);
  hrf->SetBinContent(538,0.604239);
  hrf->SetBinContent(541,0.6505255);
  hrf->SetBinContent(542,0.5818751);
  hrf->SetBinContent(543,0.5867255);
  hrf->SetBinContent(544,0.5710145);
  hrf->SetBinContent(545,0.5583379);
  hrf->SetBinContent(546,0.5236275);
  hrf->SetBinContent(547,0.5103479);
  hrf->SetBinContent(548,0.512406);
  hrf->SetBinContent(549,0.4958769);
  hrf->SetBinContent(550,0.4828178);
  hrf->SetBinContent(551,0.455934);
  hrf->SetBinContent(552,0.4250835);
  hrf->SetBinContent(553,0.3992001);
  hrf->SetBinContent(554,0.4200533);
  hrf->SetBinContent(555,0.4249736);
  hrf->SetBinContent(556,0.4012719);
  hrf->SetBinContent(557,0.44089);
  hrf->SetBinContent(558,0.4337474);
  hrf->SetBinContent(559,0.5332403);
  hrf->SetBinContent(560,0.5280592);
  hrf->SetBinContent(561,0.5309546);
  hrf->SetBinContent(562,0.481916);
  hrf->SetBinContent(563,0.5310268);
  hrf->SetBinContent(564,0.607914);
  hrf->SetBinContent(565,0.5324617);
  hrf->SetBinContent(566,0.4308392);
  hrf->SetBinContent(567,0.657365);
  hrf->SetBinContent(568,0.4871463);
  hrf->SetBinContent(569,0.48493);
  hrf->SetBinContent(570,0.5643647);
  hrf->SetBinContent(571,0.5080062);
  hrf->SetBinContent(572,0.4948668);
  hrf->SetBinContent(573,0.4924461);
  hrf->SetBinContent(574,0.4836232);
  hrf->SetBinContent(575,0.4820425);
  hrf->SetBinContent(576,0.432751);
  hrf->SetBinContent(577,0.429387);
  hrf->SetBinContent(578,0.4894068);
  hrf->SetBinContent(579,0.4042509);
  hrf->SetBinContent(580,0.4011929);
  hrf->SetBinContent(581,0.3912144);
  hrf->SetBinContent(582,0.45584);
  hrf->SetBinContent(583,0.4647456);
  hrf->SetBinContent(584,0.4363243);
  hrf->SetBinContent(585,0.4958702);
  hrf->SetBinContent(586,0.448495);
  hrf->SetBinContent(587,0.4895967);
  hrf->SetBinContent(588,0.4973783);
  hrf->SetBinContent(589,0.5330777);
  hrf->SetBinContent(590,0.5669274);
  hrf->SetBinContent(591,0.5922648);
  hrf->SetBinContent(592,0.6050142);
  hrf->SetBinContent(595,0.6630494);
  hrf->SetBinContent(596,0.6159285);
  hrf->SetBinContent(597,0.5922346);
  hrf->SetBinContent(598,0.5935339);
  hrf->SetBinContent(599,0.5428941);
  hrf->SetBinContent(600,0.5687385);
  hrf->SetBinContent(601,0.5268369);
  hrf->SetBinContent(602,0.5169364);
  hrf->SetBinContent(603,0.5499318);
  hrf->SetBinContent(604,0.5111216);
  hrf->SetBinContent(605,0.4888227);
  hrf->SetBinContent(606,0.4605286);
  hrf->SetBinContent(607,0.4351951);
  hrf->SetBinContent(608,0.431736);
  hrf->SetBinContent(609,0.414758);
  hrf->SetBinContent(610,0.4670523);
  hrf->SetBinContent(611,0.4953657);
  hrf->SetBinContent(612,0.4818059);
  hrf->SetBinContent(613,0.4936583);
  hrf->SetBinContent(614,0.5290911);
  hrf->SetBinContent(615,0.5340177);
  hrf->SetBinContent(616,0.5672857);
  hrf->SetBinContent(617,0.5451307);
  hrf->SetBinContent(618,0.5898654);
  hrf->SetBinContent(619,0.5992702);
  hrf->SetBinContent(620,0.4388121);
  hrf->SetBinContent(621,0.595104);
  hrf->SetBinContent(622,0.5084654);
  hrf->SetBinContent(623,0.6126072);
  hrf->SetBinContent(624,0.5215501);
  hrf->SetBinContent(625,0.5714918);
  hrf->SetBinContent(626,0.4984477);
  hrf->SetBinContent(627,0.5079408);
  hrf->SetBinContent(628,0.4234431);
  hrf->SetBinContent(629,0.506642);
  hrf->SetBinContent(630,0.4792702);
  hrf->SetBinContent(631,0.4516811);
  hrf->SetBinContent(632,0.5039279);
  hrf->SetBinContent(633,0.4617087);
  hrf->SetBinContent(634,0.4193281);
  hrf->SetBinContent(635,0.4421038);
  hrf->SetBinContent(636,0.4526195);
  hrf->SetBinContent(637,0.4948348);
  hrf->SetBinContent(638,0.4953995);
  hrf->SetBinContent(639,0.5809821);
  hrf->SetBinContent(640,0.4407834);
  hrf->SetBinContent(641,0.5614265);
  hrf->SetBinContent(642,0.5175495);
  hrf->SetBinContent(643,0.5785159);
  hrf->SetBinContent(644,0.5824267);
  hrf->SetBinContent(645,0.5995645);
  hrf->SetBinContent(646,0.6183428);
  hrf->SetBinContent(649,0.6631703);
  hrf->SetBinContent(650,0.6168774);
  hrf->SetBinContent(651,0.616705);
  hrf->SetBinContent(652,0.5804244);
  hrf->SetBinContent(653,0.5667811);
  hrf->SetBinContent(654,0.580375);
  hrf->SetBinContent(655,0.5548614);
  hrf->SetBinContent(656,0.5549967);
  hrf->SetBinContent(657,0.5488238);
  hrf->SetBinContent(658,0.5271744);
  hrf->SetBinContent(659,0.4692591);
  hrf->SetBinContent(660,0.4657117);
  hrf->SetBinContent(661,0.4465269);
  hrf->SetBinContent(662,0.483284);
  hrf->SetBinContent(663,0.4731859);
  hrf->SetBinContent(664,0.4757599);
  hrf->SetBinContent(665,0.5269416);
  hrf->SetBinContent(666,0.4791626);
  hrf->SetBinContent(667,0.4767701);
  hrf->SetBinContent(668,0.5280282);
  hrf->SetBinContent(669,0.471336);
  hrf->SetBinContent(670,0.5383868);
  hrf->SetBinContent(671,0.5317252);
  hrf->SetBinContent(672,0.5230907);
  hrf->SetBinContent(673,0.4193349);
  hrf->SetBinContent(674,0.6367785);
  hrf->SetBinContent(675,0.6116676);
  hrf->SetBinContent(676,5.204643e-13);
  hrf->SetBinContent(677,0.5735268);
  hrf->SetBinContent(678,0.5120812);
  hrf->SetBinContent(679,0.4439629);
  hrf->SetBinContent(680,0.5699995);
  hrf->SetBinContent(681,0.5074403);
  hrf->SetBinContent(682,0.4576817);
  hrf->SetBinContent(683,0.4833942);
  hrf->SetBinContent(684,0.4536599);
  hrf->SetBinContent(685,0.4731807);
  hrf->SetBinContent(686,0.5279117);
  hrf->SetBinContent(687,0.4941469);
  hrf->SetBinContent(688,0.4646718);
  hrf->SetBinContent(689,0.4673952);
  hrf->SetBinContent(690,0.475842);
  hrf->SetBinContent(691,0.5299788);
  hrf->SetBinContent(692,0.4936431);
  hrf->SetBinContent(693,0.5203316);
  hrf->SetBinContent(694,0.5046751);
  hrf->SetBinContent(695,0.5557889);
  hrf->SetBinContent(696,0.5674751);
  hrf->SetBinContent(697,0.561456);
  hrf->SetBinContent(698,0.6104691);
  hrf->SetBinContent(699,0.6169875);
  hrf->SetBinContent(700,0.6246719);
  hrf->SetBinContent(703,0.6720862);
  hrf->SetBinContent(704,0.502434);
  hrf->SetBinContent(705,0.6276976);
  hrf->SetBinContent(706,0.6421635);
  hrf->SetBinContent(707,0.5878988);
  hrf->SetBinContent(708,0.6358813);
  hrf->SetBinContent(709,0.5334384);
  hrf->SetBinContent(710,0.542926);
  hrf->SetBinContent(711,0.5346153);
  hrf->SetBinContent(712,0.5575447);
  hrf->SetBinContent(713,0.4793544);
  hrf->SetBinContent(714,0.4965635);
  hrf->SetBinContent(715,0.5001614);
  hrf->SetBinContent(716,0.4393831);
  hrf->SetBinContent(717,0.5190095);
  hrf->SetBinContent(718,0.5219466);
  hrf->SetBinContent(719,0.5569022);
  hrf->SetBinContent(720,0.4912303);
  hrf->SetBinContent(721,0.6012073);
  hrf->SetBinContent(722,0.5118117);
  hrf->SetBinContent(723,0.5313371);
  hrf->SetBinContent(724,0.4380699);
  hrf->SetBinContent(725,0.6676616);
  hrf->SetBinContent(726,0.5728767);
  hrf->SetBinContent(727,4.375616e-11);
  hrf->SetBinContent(728,0.6977555);
  hrf->SetBinContent(729,0.5195935);
  hrf->SetBinContent(730,0.5479189);
  hrf->SetBinContent(731,0.5616662);
  hrf->SetBinContent(732,0.4898259);
  hrf->SetBinContent(733,0.5331113);
  hrf->SetBinContent(734,0.3613676);
  hrf->SetBinContent(735,1.001784);
  hrf->SetBinContent(736,0.5572338);
  hrf->SetBinContent(737,0.5393934);
  hrf->SetBinContent(738,0.5284588);
  hrf->SetBinContent(739,0.4695196);
  hrf->SetBinContent(740,0.5750146);
  hrf->SetBinContent(741,0.4554707);
  hrf->SetBinContent(742,0.4129654);
  hrf->SetBinContent(743,0.5072033);
  hrf->SetBinContent(744,0.507525);
  hrf->SetBinContent(745,0.5350967);
  hrf->SetBinContent(746,0.4791084);
  hrf->SetBinContent(747,0.5860431);
  hrf->SetBinContent(748,0.5185009);
  hrf->SetBinContent(749,0.5168303);
  hrf->SetBinContent(750,0.5707769);
  hrf->SetBinContent(751,0.5804498);
  hrf->SetBinContent(752,0.5760176);
  hrf->SetBinContent(753,0.6006478);
  hrf->SetBinContent(754,0.6306959);
  hrf->SetBinContent(757,0.6969504);
  hrf->SetBinContent(758,0.6633195);
  hrf->SetBinContent(759,0.6902606);
  hrf->SetBinContent(760,0.7143407);
  hrf->SetBinContent(761,0.5924193);
  hrf->SetBinContent(762,0.6372157);
  hrf->SetBinContent(763,0.5941344);
  hrf->SetBinContent(764,0.6490987);
  hrf->SetBinContent(765,0.589569);
  hrf->SetBinContent(766,0.6097816);
  hrf->SetBinContent(767,0.6370956);
  hrf->SetBinContent(768,0.5543383);
  hrf->SetBinContent(769,0.5394284);
  hrf->SetBinContent(770,0.5702426);
  hrf->SetBinContent(771,0.5809673);
  hrf->SetBinContent(772,0.6057459);
  hrf->SetBinContent(773,0.5444764);
  hrf->SetBinContent(774,0.5634755);
  hrf->SetBinContent(775,0.5966855);
  hrf->SetBinContent(776,0.1905186);
  hrf->SetBinContent(777,0.5290856);
  hrf->SetBinContent(778,0.560666);
  hrf->SetBinContent(779,0.6940724);
  hrf->SetBinContent(780,0.568481);
  hrf->SetBinContent(781,5.137732e-09);
  hrf->SetBinContent(782,0.6693913);
  hrf->SetBinContent(783,2);
  hrf->SetBinContent(784,0.5789571);
  hrf->SetBinContent(785,5.583899e-10);
  hrf->SetBinContent(786,0.7291753);
  hrf->SetBinContent(787,0.6024151);
  hrf->SetBinContent(788,0.4010713);
  hrf->SetBinContent(789,0.5439928);
  hrf->SetBinContent(790,0.557969);
  hrf->SetBinContent(791,0.463603);
  hrf->SetBinContent(792,0.5785179);
  hrf->SetBinContent(793,0.6177458);
  hrf->SetBinContent(794,0.593899);
  hrf->SetBinContent(795,0.5544063);
  hrf->SetBinContent(796,0.5700239);
  hrf->SetBinContent(797,0.5639662);
  hrf->SetBinContent(798,0.499365);
  hrf->SetBinContent(799,0.5454815);
  hrf->SetBinContent(800,0.5449318);
  hrf->SetBinContent(801,0.9383752);
  hrf->SetBinContent(802,0.5473474);
  hrf->SetBinContent(803,0.5602657);
  hrf->SetBinContent(804,0.5743401);
  hrf->SetBinContent(805,0.6341625);
  hrf->SetBinContent(806,0.6491289);
  hrf->SetBinContent(807,0.6202378);
  hrf->SetBinContent(808,0.6635697);
  hrf->SetBinContent(811,0.68841);
  hrf->SetBinContent(812,0.6655799);
  hrf->SetBinContent(813,0.5721935);
  hrf->SetBinContent(814,0.6535349);
  hrf->SetBinContent(815,0.7027519);
  hrf->SetBinContent(816,0.6477481);
  hrf->SetBinContent(817,0.648778);
  hrf->SetBinContent(818,0.6354568);
  hrf->SetBinContent(819,0.5172462);
  hrf->SetBinContent(820,0.5781944);
  hrf->SetBinContent(821,0.6477975);
  hrf->SetBinContent(822,0.6004694);
  hrf->SetBinContent(823,0.6332108);
  hrf->SetBinContent(824,0.5979394);
  hrf->SetBinContent(825,0.6150681);
  hrf->SetBinContent(826,0.5580107);
  hrf->SetBinContent(827,0.6403232);
  hrf->SetBinContent(828,0.6658844);
  hrf->SetBinContent(829,0.7569863);
  hrf->SetBinContent(830,0.6020923);
  hrf->SetBinContent(831,2.16818e-07);
  hrf->SetBinContent(832,0.7211751);
  hrf->SetBinContent(833,0.7200035);
  hrf->SetBinContent(834,0.6769444);
  hrf->SetBinContent(835,0.6245867);
  hrf->SetBinContent(836,0.6035547);
  hrf->SetBinContent(837,0.6902707);
  hrf->SetBinContent(838,0.5134299);
  hrf->SetBinContent(839,2.329299e-08);
  hrf->SetBinContent(840,2);
  hrf->SetBinContent(841,0.6745621);
  hrf->SetBinContent(842,0.676607);
  hrf->SetBinContent(843,2);
  hrf->SetBinContent(844,0.6654628);
  hrf->SetBinContent(845,0.6554278);
  hrf->SetBinContent(846,0.5387945);
  hrf->SetBinContent(847,0.6195349);
  hrf->SetBinContent(848,0.6509743);
  hrf->SetBinContent(849,0.5995178);
  hrf->SetBinContent(850,0.5589016);
  hrf->SetBinContent(851,0.584215);
  hrf->SetBinContent(852,0.5316675);
  hrf->SetBinContent(853,0.5770031);
  hrf->SetBinContent(854,0.6059638);
  hrf->SetBinContent(855,0.7237309);
  hrf->SetBinContent(856,0.4882735);
  hrf->SetBinContent(857,0.5033463);
  hrf->SetBinContent(858,0.6661474);
  hrf->SetBinContent(859,0.6508684);
  hrf->SetBinContent(860,0.6549551);
  hrf->SetBinContent(861,0.6838532);
  hrf->SetBinContent(862,0.742049);
  hrf->SetBinContent(865,0.7438933);
  hrf->SetBinContent(866,0.6990814);
  hrf->SetBinContent(867,0.6386996);
  hrf->SetBinContent(868,0.6660725);
  hrf->SetBinContent(869,0.6112747);
  hrf->SetBinContent(870,0.6274318);
  hrf->SetBinContent(871,0.6963621);
  hrf->SetBinContent(872,0.685574);
  hrf->SetBinContent(873,0.5979159);
  hrf->SetBinContent(874,0.6452025);
  hrf->SetBinContent(875,0.6139266);
  hrf->SetBinContent(876,0.6035063);
  hrf->SetBinContent(877,0.612106);
  hrf->SetBinContent(878,0.5961891);
  hrf->SetBinContent(879,0.6140286);
  hrf->SetBinContent(880,0.6286171);
  hrf->SetBinContent(881,0.7334413);
  hrf->SetBinContent(882,0.697404);
  hrf->SetBinContent(883,0.6126003);
  hrf->SetBinContent(884,0.6123802);
  hrf->SetBinContent(885,1.288313e-10);
  hrf->SetBinContent(886,0.6302402);
  hrf->SetBinContent(887,0.6052687);
  hrf->SetBinContent(888,0.7380156);
  hrf->SetBinContent(889,2.948208e-09);
  hrf->SetBinContent(890,0.724287);
  hrf->SetBinContent(891,0.6359965);
  hrf->SetBinContent(892,0.6981551);
  hrf->SetBinContent(893,2);
  hrf->SetBinContent(894,0.7462012);
  hrf->SetBinContent(895,0.6442341);
  hrf->SetBinContent(896,0.7292137);
  hrf->SetBinContent(897,0.7199974);
  hrf->SetBinContent(898,0.621317);
  hrf->SetBinContent(899,0.5854515);
  hrf->SetBinContent(900,0.5760161);
  hrf->SetBinContent(901,0.6657082);
  hrf->SetBinContent(902,0.6135329);
  hrf->SetBinContent(903,0.608986);
  hrf->SetBinContent(904,0.549113);
  hrf->SetBinContent(905,0.5866095);
  hrf->SetBinContent(906,0.6221043);
  hrf->SetBinContent(907,0.6219515);
  hrf->SetBinContent(908,0.4862638);
  hrf->SetBinContent(909,0.6301283);
  hrf->SetBinContent(910,0.555077);
  hrf->SetBinContent(911,0.6804049);
  hrf->SetBinContent(912,0.5539804);
  hrf->SetBinContent(913,0.6536226);
  hrf->SetBinContent(914,0.6983255);
  hrf->SetBinContent(915,0.6382693);
  hrf->SetBinContent(916,0.754311);
  hrf->SetBinContent(919,0.7099376);
  hrf->SetBinContent(920,0.8623501);
  hrf->SetBinContent(921,0.7260902);
  hrf->SetBinContent(922,0.6643114);
  hrf->SetBinContent(923,0.6502191);
  hrf->SetBinContent(924,0.7040369);
  hrf->SetBinContent(925,0.6131998);
  hrf->SetBinContent(926,0.7646526);
  hrf->SetBinContent(927,0.5962986);
  hrf->SetBinContent(928,0.674045);
  hrf->SetBinContent(929,0.6392841);
  hrf->SetBinContent(930,0.6779032);
  hrf->SetBinContent(931,0.6079232);
  hrf->SetBinContent(932,0.6311303);
  hrf->SetBinContent(933,0.610688);
  hrf->SetBinContent(934,0.6147182);
  hrf->SetBinContent(935,1.551637e-10);
  hrf->SetBinContent(936,4.418874e-10);
  hrf->SetBinContent(937,0.7821836);
  hrf->SetBinContent(938,1.62191);
  hrf->SetBinContent(939,0.6386381);
  hrf->SetBinContent(940,0.7198481);
  hrf->SetBinContent(941,0.6799192);
  hrf->SetBinContent(942,0.6402811);
  hrf->SetBinContent(943,1.357403e-09);
  hrf->SetBinContent(944,0.7030411);
  hrf->SetBinContent(945,0.6865827);
  hrf->SetBinContent(946,0.5293041);
  hrf->SetBinContent(947,4.159337e-10);
  hrf->SetBinContent(948,6.025262e-08);
  hrf->SetBinContent(949,0.5823747);
  hrf->SetBinContent(950,0.5866954);
  hrf->SetBinContent(951,0.6885952);
  hrf->SetBinContent(952,0.298851);
  hrf->SetBinContent(953,0.6920147);
  hrf->SetBinContent(954,0.6756617);
  hrf->SetBinContent(955,0.5811628);
  hrf->SetBinContent(956,0.5984484);
  hrf->SetBinContent(957,0.5995011);
  hrf->SetBinContent(958,0.5685067);
  hrf->SetBinContent(959,0.6030776);
  hrf->SetBinContent(960,0.5949068);
  hrf->SetBinContent(961,0.6138204);
  hrf->SetBinContent(962,0.7262517);
  hrf->SetBinContent(963,0.7460917);
  hrf->SetBinContent(964,0.7254511);
  hrf->SetBinContent(965,0.7218192);
  hrf->SetBinContent(966,0.636579);
  hrf->SetBinContent(967,0.6403494);
  hrf->SetBinContent(968,0.7431021);
  hrf->SetBinContent(969,0.6745241);
  hrf->SetBinContent(970,0.7573865);
  hrf->SetBinContent(973,0.6918843);
  hrf->SetBinContent(974,0.7262695);
  hrf->SetBinContent(975,0.7153355);
  hrf->SetBinContent(976,0.690676);
  hrf->SetBinContent(977,0.7087989);
  hrf->SetBinContent(978,0.7161497);
  hrf->SetBinContent(979,0.7017328);
  hrf->SetBinContent(980,0.7252781);
  hrf->SetBinContent(981,0.7966533);
  hrf->SetBinContent(982,0.688317);
  hrf->SetBinContent(983,0.5986019);
  hrf->SetBinContent(984,0.6506643);
  hrf->SetBinContent(985,0.637751);
  hrf->SetBinContent(986,0.6715163);
  hrf->SetBinContent(987,0.6517788);
  hrf->SetBinContent(988,0.734043);
  hrf->SetBinContent(989,0.7398574);
  hrf->SetBinContent(990,0.6567512);
  hrf->SetBinContent(991,0.7622219);
  hrf->SetBinContent(992,0.7801381);
  hrf->SetBinContent(993,6.677729e-11);
  hrf->SetBinContent(994,0.584604);
  hrf->SetBinContent(995,0.8659359);
  hrf->SetBinContent(996,0.4751396);
  hrf->SetBinContent(997,0.6154816);
  hrf->SetBinContent(998,0.8736457);
  hrf->SetBinContent(999,0.6989418);
  hrf->SetBinContent(1000,0.534987);
  hrf->SetBinContent(1001,0.7178237);
  hrf->SetBinContent(1002,0.6590059);
  hrf->SetBinContent(1003,0.6578107);
  hrf->SetBinContent(1004,0.6319634);
  hrf->SetBinContent(1005,0.729422);
  hrf->SetBinContent(1006,0.7260677);
  hrf->SetBinContent(1007,0.5859498);
  hrf->SetBinContent(1008,0.6200585);
  hrf->SetBinContent(1009,0.69023);
  hrf->SetBinContent(1010,0.6844075);
  hrf->SetBinContent(1011,0.6791952);
  hrf->SetBinContent(1012,0.6411185);
  hrf->SetBinContent(1013,0.6361954);
  hrf->SetBinContent(1014,0.6158186);
  hrf->SetBinContent(1015,0.6525335);
  hrf->SetBinContent(1016,0.6840788);
  hrf->SetBinContent(1017,0.6705694);
  hrf->SetBinContent(1018,0.6812602);
  hrf->SetBinContent(1019,0.7209173);
  hrf->SetBinContent(1020,0.6611741);
  hrf->SetBinContent(1021,0.5270574);
  hrf->SetBinContent(1022,0.6960925);
  hrf->SetBinContent(1023,0.7432538);
  hrf->SetBinContent(1024,0.7469128);
  hrf->SetBinContent(1027,0.7886937);
  hrf->SetBinContent(1028,0.7728928);
  hrf->SetBinContent(1029,0.734811);
  hrf->SetBinContent(1030,0.7348018);
  hrf->SetBinContent(1031,0.7228283);
  hrf->SetBinContent(1032,0.6900923);
  hrf->SetBinContent(1033,0.7324901);
  hrf->SetBinContent(1034,0.818476);
  hrf->SetBinContent(1035,0.7755879);
  hrf->SetBinContent(1036,0.7029133);
  hrf->SetBinContent(1037,0.6488961);
  hrf->SetBinContent(1038,0.643996);
  hrf->SetBinContent(1039,0.6234887);
  hrf->SetBinContent(1040,0.665674);
  hrf->SetBinContent(1041,0.6890448);
  hrf->SetBinContent(1042,0.7474747);
  hrf->SetBinContent(1043,0.6217731);
  hrf->SetBinContent(1044,0.7594035);
  hrf->SetBinContent(1045,0.7606437);
  hrf->SetBinContent(1046,0.8798572);
  hrf->SetBinContent(1047,1.523508e-12);
  hrf->SetBinContent(1048,0.7667443);
  hrf->SetBinContent(1049,8.919419e-10);
  hrf->SetBinContent(1050,0.7775083);
  hrf->SetBinContent(1051,0.7051193);
  hrf->SetBinContent(1052,0.7821314);
  hrf->SetBinContent(1053,0.3696456);
  hrf->SetBinContent(1054,0.7040802);
  hrf->SetBinContent(1055,0.7243683);
  hrf->SetBinContent(1056,2);
  hrf->SetBinContent(1057,1.910918e-09);
  hrf->SetBinContent(1058,0.6928734);
  hrf->SetBinContent(1059,0.6995317);
  hrf->SetBinContent(1060,0.707352);
  hrf->SetBinContent(1061,0.7905835);
  hrf->SetBinContent(1062,0.7529305);
  hrf->SetBinContent(1063,0.6234255);
  hrf->SetBinContent(1064,0.6901059);
  hrf->SetBinContent(1065,0.6871264);
  hrf->SetBinContent(1066,0.6963648);
  hrf->SetBinContent(1067,0.6620449);
  hrf->SetBinContent(1068,0.6847797);
  hrf->SetBinContent(1069,0.6602038);
  hrf->SetBinContent(1070,0.6530365);
  hrf->SetBinContent(1071,0.6900207);
  hrf->SetBinContent(1072,0.6818995);
  hrf->SetBinContent(1073,0.7123579);
  hrf->SetBinContent(1074,0.7515758);
  hrf->SetBinContent(1075,0.7347609);
  hrf->SetBinContent(1076,0.7230546);
  hrf->SetBinContent(1077,0.7335827);
  hrf->SetBinContent(1078,0.7987013);
  hrf->SetBinContent(1081,0.8701817);
  hrf->SetBinContent(1082,0.7909325);
  hrf->SetBinContent(1083,0.7988487);
  hrf->SetBinContent(1084,0.7315447);
  hrf->SetBinContent(1085,0.7445458);
  hrf->SetBinContent(1086,0.719189);
  hrf->SetBinContent(1087,0.6976324);
  hrf->SetBinContent(1088,0.7098625);
  hrf->SetBinContent(1089,0.7585338);
  hrf->SetBinContent(1090,0.7951381);
  hrf->SetBinContent(1091,0.6906781);
  hrf->SetBinContent(1092,0.6984041);
  hrf->SetBinContent(1093,0.7071833);
  hrf->SetBinContent(1094,0.7389575);
  hrf->SetBinContent(1095,0.6932821);
  hrf->SetBinContent(1096,0.7635614);
  hrf->SetBinContent(1097,0.735354);
  hrf->SetBinContent(1098,0.6733291);
  hrf->SetBinContent(1099,0.6815611);
  hrf->SetBinContent(1100,0.7698269);
  hrf->SetBinContent(1101,7.031095e-10);
  hrf->SetBinContent(1102,0.902009);
  hrf->SetBinContent(1103,0.7199787);
  hrf->SetBinContent(1104,0.8753546);
  hrf->SetBinContent(1105,0.7691409);
  hrf->SetBinContent(1106,0.8032231);
  hrf->SetBinContent(1107,0.7608244);
  hrf->SetBinContent(1108,0.6909539);
  hrf->SetBinContent(1109,0.75949);
  hrf->SetBinContent(1110,0.6740589);
  hrf->SetBinContent(1111,0.8500618);
  hrf->SetBinContent(1112,0.3840883);
  hrf->SetBinContent(1113,0.8179412);
  hrf->SetBinContent(1114,0.756898);
  hrf->SetBinContent(1115,0.7581729);
  hrf->SetBinContent(1116,0.7334068);
  hrf->SetBinContent(1117,0.6974013);
  hrf->SetBinContent(1118,0.7137154);
  hrf->SetBinContent(1119,0.7129677);
  hrf->SetBinContent(1120,0.6707702);
  hrf->SetBinContent(1121,0.6722126);
  hrf->SetBinContent(1122,0.6974467);
  hrf->SetBinContent(1123,0.7031453);
  hrf->SetBinContent(1124,0.657684);
  hrf->SetBinContent(1125,0.7449268);
  hrf->SetBinContent(1126,0.874833);
  hrf->SetBinContent(1127,0.9745963);
  hrf->SetBinContent(1128,0.7741645);
  hrf->SetBinContent(1129,0.7339757);
  hrf->SetBinContent(1130,0.777975);
  hrf->SetBinContent(1131,0.7915074);
  hrf->SetBinContent(1132,0.6136767);
  hrf->SetBinContent(1135,0.8755973);
  hrf->SetBinContent(1136,0.7700605);
  hrf->SetBinContent(1137,0.8033186);
  hrf->SetBinContent(1138,0.7555612);
  hrf->SetBinContent(1139,0.7591759);
  hrf->SetBinContent(1140,0.7519722);
  hrf->SetBinContent(1141,0.7289418);
  hrf->SetBinContent(1142,1.346851);
  hrf->SetBinContent(1143,0.6687253);
  hrf->SetBinContent(1144,0.717847);
  hrf->SetBinContent(1145,0.7011801);
  hrf->SetBinContent(1146,0.6966033);
  hrf->SetBinContent(1147,0.6946036);
  hrf->SetBinContent(1148,0.7405895);
  hrf->SetBinContent(1149,0.7328261);
  hrf->SetBinContent(1150,0.7192682);
  hrf->SetBinContent(1151,0.8046057);
  hrf->SetBinContent(1152,0.7620371);
  hrf->SetBinContent(1153,0.7501711);
  hrf->SetBinContent(1154,0.6792978);
  hrf->SetBinContent(1155,0.7581177);
  hrf->SetBinContent(1156,0.8915533);
  hrf->SetBinContent(1157,0.7304667);
  hrf->SetBinContent(1158,1.778186e-08);
  hrf->SetBinContent(1159,0.7876914);
  hrf->SetBinContent(1160,0.8167171);
  hrf->SetBinContent(1161,0.799203);
  hrf->SetBinContent(1162,1.564839);
  hrf->SetBinContent(1163,1.932414);
  hrf->SetBinContent(1164,0.6999876);
  hrf->SetBinContent(1165,0.8222277);
  hrf->SetBinContent(1166,0.7073811);
  hrf->SetBinContent(1167,0.760646);
  hrf->SetBinContent(1168,0.8145632);
  hrf->SetBinContent(1169,0.6570073);
  hrf->SetBinContent(1170,0.7903656);
  hrf->SetBinContent(1171,0.7055761);
  hrf->SetBinContent(1172,0.7324432);
  hrf->SetBinContent(1173,0.6906474);
  hrf->SetBinContent(1174,0.7016042);
  hrf->SetBinContent(1175,0.6910746);
  hrf->SetBinContent(1176,0.6489437);
  hrf->SetBinContent(1177,0.7277918);
  hrf->SetBinContent(1178,0.8176938);
  hrf->SetBinContent(1179,0.7668142);
  hrf->SetBinContent(1180,0.6988779);
  hrf->SetBinContent(1181,4.715625e-10);
  hrf->SetBinContent(1182,0.7289456);
  hrf->SetBinContent(1183,0.8265013);
  hrf->SetBinContent(1184,0.7507662);
  hrf->SetBinContent(1185,0.7896848);
  hrf->SetBinContent(1186,0.7976325);
  hrf->SetBinContent(1189,0.8057601);
  hrf->SetBinContent(1190,1.370117);
  hrf->SetBinContent(1191,0.77344);
  hrf->SetBinContent(1192,0.7452468);
  hrf->SetBinContent(1193,1.108199);
  hrf->SetBinContent(1194,3.7291e-08);
  hrf->SetBinContent(1195,0.7778447);
  hrf->SetBinContent(1196,0.7805797);
  hrf->SetBinContent(1197,0.8029034);
  hrf->SetBinContent(1198,0.7143188);
  hrf->SetBinContent(1199,0.7026921);
  hrf->SetBinContent(1200,0.689998);
  hrf->SetBinContent(1201,0.7199291);
  hrf->SetBinContent(1202,0.749867);
  hrf->SetBinContent(1203,0.7412875);
  hrf->SetBinContent(1204,0.7532368);
  hrf->SetBinContent(1205,0.7416354);
  hrf->SetBinContent(1206,0.7788702);
  hrf->SetBinContent(1207,0.75921);
  hrf->SetBinContent(1208,0.9899771);
  hrf->SetBinContent(1209,0.8028721);
  hrf->SetBinContent(1210,0.7613076);
  hrf->SetBinContent(1211,0.8038316);
  hrf->SetBinContent(1212,2);
  hrf->SetBinContent(1213,0.8121575);
  hrf->SetBinContent(1214,0.7813477);
  hrf->SetBinContent(1215,0.7840589);
  hrf->SetBinContent(1216,0.8885684);
  hrf->SetBinContent(1217,2.145997e-08);
  hrf->SetBinContent(1218,0.7463155);
  hrf->SetBinContent(1219,0.7435377);
  hrf->SetBinContent(1220,1.193651);
  hrf->SetBinContent(1221,0.8411264);
  hrf->SetBinContent(1222,0.8833549);
  hrf->SetBinContent(1223,0.8037913);
  hrf->SetBinContent(1224,0.7233331);
  hrf->SetBinContent(1225,0.7553903);
  hrf->SetBinContent(1226,0.8175085);
  hrf->SetBinContent(1227,0.7190688);
  hrf->SetBinContent(1228,0.7042091);
  hrf->SetBinContent(1229,0.7236426);
  hrf->SetBinContent(1230,0.7486491);
  hrf->SetBinContent(1231,0.6273947);
  hrf->SetBinContent(1232,0.7902668);
  hrf->SetBinContent(1233,0.7747761);
  hrf->SetBinContent(1234,1.884267e-08);
  hrf->SetBinContent(1235,0.7297846);
  hrf->SetBinContent(1236,0.7674142);
  hrf->SetBinContent(1237,0.7560349);
  hrf->SetBinContent(1238,0.7615343);
  hrf->SetBinContent(1239,0.8092088);
  hrf->SetBinContent(1240,0.837832);
  hrf->SetBinContent(1243,0.8410632);
  hrf->SetBinContent(1244,0.8284886);
  hrf->SetBinContent(1245,0.8323252);
  hrf->SetBinContent(1246,0.7917008);
  hrf->SetBinContent(1247,0.8252153);
  hrf->SetBinContent(1248,0.7736288);
  hrf->SetBinContent(1249,2.79689e-08);
  hrf->SetBinContent(1250,0.8256513);
  hrf->SetBinContent(1251,0.788981);
  hrf->SetBinContent(1252,0.7069463);
  hrf->SetBinContent(1253,0.7353773);
  hrf->SetBinContent(1254,0.7264474);
  hrf->SetBinContent(1255,0.709739);
  hrf->SetBinContent(1256,0.6967523);
  hrf->SetBinContent(1257,0.7593404);
  hrf->SetBinContent(1258,0.6857809);
  hrf->SetBinContent(1259,0.7538165);
  hrf->SetBinContent(1260,0.8193203);
  hrf->SetBinContent(1261,1.12253);
  hrf->SetBinContent(1262,0.8099769);
  hrf->SetBinContent(1263,0.7968184);
  hrf->SetBinContent(1264,0.7165168);
  hrf->SetBinContent(1265,0.841195);
  hrf->SetBinContent(1266,0.7307236);
  hrf->SetBinContent(1267,0.7757208);
  hrf->SetBinContent(1268,1.175732);
  hrf->SetBinContent(1269,0.7950296);
  hrf->SetBinContent(1270,2.153397e-08);
  hrf->SetBinContent(1271,0.7121626);
  hrf->SetBinContent(1272,0.7998994);
  hrf->SetBinContent(1273,0.7731178);
  hrf->SetBinContent(1274,2);
  hrf->SetBinContent(1275,0.6647769);
  hrf->SetBinContent(1276,0.7917477);
  hrf->SetBinContent(1277,0.797781);
  hrf->SetBinContent(1278,0.7394993);
  hrf->SetBinContent(1279,0.7469406);
  hrf->SetBinContent(1280,0.7587091);
  hrf->SetBinContent(1281,0.7714839);
  hrf->SetBinContent(1282,0.7415178);
  hrf->SetBinContent(1283,0.6940494);
  hrf->SetBinContent(1284,0.6900583);
  hrf->SetBinContent(1285,0.744396);
  hrf->SetBinContent(1286,0.7567286);
  hrf->SetBinContent(1287,0.7837025);
  hrf->SetBinContent(1288,0.7640251);
  hrf->SetBinContent(1289,2);
  hrf->SetBinContent(1290,0.7397066);
  hrf->SetBinContent(1291,0.6930763);
  hrf->SetBinContent(1292,0.7849539);
  hrf->SetBinContent(1293,0.7758456);
  hrf->SetBinContent(1294,0.8567303);
  hrf->SetBinContent(1297,0.8105354);
  hrf->SetBinContent(1298,0.8642945);
  hrf->SetBinContent(1299,0.8043556);
  hrf->SetBinContent(1300,0.819859);
  hrf->SetBinContent(1301,0.7584703);
  hrf->SetBinContent(1302,0.7616698);
  hrf->SetBinContent(1303,0.7812502);
  hrf->SetBinContent(1304,0.8144913);
  hrf->SetBinContent(1305,0.8069767);
  hrf->SetBinContent(1306,0.7869472);
  hrf->SetBinContent(1307,0.7356938);
  hrf->SetBinContent(1308,0.7303469);
  hrf->SetBinContent(1309,0.7237442);
  hrf->SetBinContent(1310,0.7893888);
  hrf->SetBinContent(1311,0.7743256);
  hrf->SetBinContent(1312,0.7478973);
  hrf->SetBinContent(1313,0.7472924);
  hrf->SetBinContent(1314,0.7928523);
  hrf->SetBinContent(1315,0.6974202);
  hrf->SetBinContent(1316,0.8026988);
  hrf->SetBinContent(1317,0.8257939);
  hrf->SetBinContent(1318,0.831494);
  hrf->SetBinContent(1319,0.7945051);
  hrf->SetBinContent(1320,0.761869);
  hrf->SetBinContent(1321,0.7518338);
  hrf->SetBinContent(1322,0.7769849);
  hrf->SetBinContent(1323,0.7716518);
  hrf->SetBinContent(1324,0.7334756);
  hrf->SetBinContent(1325,0.8503541);
  hrf->SetBinContent(1326,0.8200087);
  hrf->SetBinContent(1327,0.7371234);
  hrf->SetBinContent(1328,0.852895);
  hrf->SetBinContent(1329,0.8021988);
  hrf->SetBinContent(1330,1.039027);
  hrf->SetBinContent(1331,0.7118308);
  hrf->SetBinContent(1332,0.7804436);
  hrf->SetBinContent(1333,0.7621835);
  hrf->SetBinContent(1334,0.7786251);
  hrf->SetBinContent(1335,0.7262275);
  hrf->SetBinContent(1336,0.7599275);
  hrf->SetBinContent(1337,0.7669863);
  hrf->SetBinContent(1338,0.7006092);
  hrf->SetBinContent(1339,0.7275499);
  hrf->SetBinContent(1340,0.8066881);
  hrf->SetBinContent(1341,8.082332e-09);
  hrf->SetBinContent(1342,0.8027337);
  hrf->SetBinContent(1343,0.7597497);
  hrf->SetBinContent(1344,0.7935027);
  hrf->SetBinContent(1345,0.763325);
  hrf->SetBinContent(1346,0.7717389);
  hrf->SetBinContent(1347,0.7577329);
  hrf->SetBinContent(1348,0.88808);
  hrf->SetBinContent(1351,0.8976908);
  hrf->SetBinContent(1352,0.8423946);
  hrf->SetBinContent(1353,0.8284513);
  hrf->SetBinContent(1354,0.8412279);
  hrf->SetBinContent(1355,0.8500894);
  hrf->SetBinContent(1356,9.257798e-11);
  hrf->SetBinContent(1357,0.7810383);
  hrf->SetBinContent(1358,0.8704037);
  hrf->SetBinContent(1359,0.8300052);
  hrf->SetBinContent(1360,0.7825852);
  hrf->SetBinContent(1361,0.816828);
  hrf->SetBinContent(1362,0.7973738);
  hrf->SetBinContent(1363,0.7527605);
  hrf->SetBinContent(1364,0.7771426);
  hrf->SetBinContent(1365,0.9042388);
  hrf->SetBinContent(1366,0.8078419);
  hrf->SetBinContent(1367,0.7744836);
  hrf->SetBinContent(1368,0.8064706);
  hrf->SetBinContent(1369,0.7996269);
  hrf->SetBinContent(1370,0.8434137);
  hrf->SetBinContent(1371,0.8069958);
  hrf->SetBinContent(1372,0.8413141);
  hrf->SetBinContent(1373,0.321352);
  hrf->SetBinContent(1374,0.8889853);
  hrf->SetBinContent(1375,0.4442552);
  hrf->SetBinContent(1376,0.8282964);
  hrf->SetBinContent(1377,0.6055968);
  hrf->SetBinContent(1378,2);
  hrf->SetBinContent(1379,0.758385);
  hrf->SetBinContent(1380,0.8161163);
  hrf->SetBinContent(1381,0.7797145);
  hrf->SetBinContent(1382,0.826297);
  hrf->SetBinContent(1383,0.8015526);
  hrf->SetBinContent(1384,0.7983635);
  hrf->SetBinContent(1385,0.7639591);
  hrf->SetBinContent(1386,0.8086007);
  hrf->SetBinContent(1387,0.8069662);
  hrf->SetBinContent(1388,0.8426892);
  hrf->SetBinContent(1389,0.7772759);
  hrf->SetBinContent(1390,0.7175232);
  hrf->SetBinContent(1391,0.782493);
  hrf->SetBinContent(1392,0.7797878);
  hrf->SetBinContent(1393,0.7351255);
  hrf->SetBinContent(1394,0.7613439);
  hrf->SetBinContent(1395,0.7944787);
  hrf->SetBinContent(1396,0.842592);
  hrf->SetBinContent(1397,0.7760797);
  hrf->SetBinContent(1398,0.8138054);
  hrf->SetBinContent(1399,0.8470539);
  hrf->SetBinContent(1400,0.7994559);
  hrf->SetBinContent(1401,0.8828442);
  hrf->SetBinContent(1402,0.9125168);
  hrf->SetBinContent(1405,0.7432123);
  hrf->SetBinContent(1406,0.7924839);
  hrf->SetBinContent(1407,0.8402076);
  hrf->SetBinContent(1408,0.8734859);
  hrf->SetBinContent(1409,0.8290992);
  hrf->SetBinContent(1410,0.8127977);
  hrf->SetBinContent(1411,0.8719417);
  hrf->SetBinContent(1412,0.8320817);
  hrf->SetBinContent(1413,0.8709081);
  hrf->SetBinContent(1414,0.8365571);
  hrf->SetBinContent(1415,0.7768795);
  hrf->SetBinContent(1416,0.8100523);
  hrf->SetBinContent(1417,0.7853265);
  hrf->SetBinContent(1418,0.8136188);
  hrf->SetBinContent(1419,0.7901163);
  hrf->SetBinContent(1420,0.8603168);
  hrf->SetBinContent(1421,0.8527932);
  hrf->SetBinContent(1422,0.8367243);
  hrf->SetBinContent(1423,0.8095203);
  hrf->SetBinContent(1424,0.836165);
  hrf->SetBinContent(1425,0.7613062);
  hrf->SetBinContent(1426,1.108609);
  hrf->SetBinContent(1427,0.1380128);
  hrf->SetBinContent(1428,0.8434393);
  hrf->SetBinContent(1429,0.929493);
  hrf->SetBinContent(1430,0.891273);
  hrf->SetBinContent(1431,0.9241241);
  hrf->SetBinContent(1432,0.8175316);
  hrf->SetBinContent(1433,0.8373544);
  hrf->SetBinContent(1434,0.8248472);
  hrf->SetBinContent(1435,0.9091666);
  hrf->SetBinContent(1436,0.8176399);
  hrf->SetBinContent(1437,1.605745);
  hrf->SetBinContent(1438,0.3585472);
  hrf->SetBinContent(1439,0.8094559);
  hrf->SetBinContent(1440,0.8123945);
  hrf->SetBinContent(1441,0.8034517);
  hrf->SetBinContent(1442,0.7874666);
  hrf->SetBinContent(1443,0.8026767);
  hrf->SetBinContent(1444,0.7624008);
  hrf->SetBinContent(1445,0.7767704);
  hrf->SetBinContent(1446,0.7053043);
  hrf->SetBinContent(1447,0.7737352);
  hrf->SetBinContent(1448,0.8538612);
  hrf->SetBinContent(1449,0.835044);
  hrf->SetBinContent(1450,0.7230772);
  hrf->SetBinContent(1451,0.8203293);
  hrf->SetBinContent(1452,0.8326061);
  hrf->SetBinContent(1453,0.838903);
  hrf->SetBinContent(1454,0.8315706);
  hrf->SetBinContent(1455,0.8732846);
  hrf->SetBinContent(1456,0.7947215);
  hrf->SetBinContent(1459,0.8947669);
  hrf->SetBinContent(1460,0.8324007);
  hrf->SetBinContent(1461,0.7979457);
  hrf->SetBinContent(1462,2);
  hrf->SetBinContent(1463,0.8209487);
  hrf->SetBinContent(1464,0.8033738);
  hrf->SetBinContent(1465,0.7823778);
  hrf->SetBinContent(1466,0.8794152);
  hrf->SetBinContent(1467,0.8407297);
  hrf->SetBinContent(1468,0.8277702);
  hrf->SetBinContent(1469,0.810888);
  hrf->SetBinContent(1470,0.7680818);
  hrf->SetBinContent(1471,0.8095968);
  hrf->SetBinContent(1472,0.790924);
  hrf->SetBinContent(1473,0.8457994);
  hrf->SetBinContent(1474,0.8210438);
  hrf->SetBinContent(1475,0.8473524);
  hrf->SetBinContent(1476,2.701161e-08);
  hrf->SetBinContent(1477,0.8416434);
  hrf->SetBinContent(1478,0.8278685);
  hrf->SetBinContent(1479,0.9409888);
  hrf->SetBinContent(1480,0.8393762);
  hrf->SetBinContent(1481,0.8670172);
  hrf->SetBinContent(1482,0.8475037);
  hrf->SetBinContent(1483,0.4279374);
  hrf->SetBinContent(1484,0.9529459);
  hrf->SetBinContent(1485,0.8614377);
  hrf->SetBinContent(1486,2);
  hrf->SetBinContent(1487,0.8818654);
  hrf->SetBinContent(1488,0.8004858);
  hrf->SetBinContent(1489,0.8546413);
  hrf->SetBinContent(1490,1.999866);
  hrf->SetBinContent(1491,0.815396);
  hrf->SetBinContent(1492,0.7853104);
  hrf->SetBinContent(1493,0.8461049);
  hrf->SetBinContent(1494,0.8015136);
  hrf->SetBinContent(1495,0.7569559);
  hrf->SetBinContent(1496,0.8288024);
  hrf->SetBinContent(1497,0.7886032);
  hrf->SetBinContent(1498,0.7762703);
  hrf->SetBinContent(1499,0.770609);
  hrf->SetBinContent(1500,0.817199);
  hrf->SetBinContent(1501,0.7620718);
  hrf->SetBinContent(1502,0.8152385);
  hrf->SetBinContent(1503,0.8691072);
  hrf->SetBinContent(1504,0.8155018);
  hrf->SetBinContent(1505,0.8496901);
  hrf->SetBinContent(1506,0.7108539);
  hrf->SetBinContent(1507,0.856768);
  hrf->SetBinContent(1508,0.7733098);
  hrf->SetBinContent(1509,0.8095035);
  hrf->SetBinContent(1510,1.06417);
  hrf->SetBinContent(1513,0.9013685);
  hrf->SetBinContent(1514,0.7900718);
  hrf->SetBinContent(1515,0.7571104);
  hrf->SetBinContent(1516,0.797836);
  hrf->SetBinContent(1517,0.8264311);
  hrf->SetBinContent(1518,0.800528);
  hrf->SetBinContent(1519,0.8707364);
  hrf->SetBinContent(1520,0.8413364);
  hrf->SetBinContent(1521,0.6594373);
  hrf->SetBinContent(1522,0.8289098);
  hrf->SetBinContent(1523,0.7821766);
  hrf->SetBinContent(1524,0.8083399);
  hrf->SetBinContent(1525,0.7758535);
  hrf->SetBinContent(1526,0.8410822);
  hrf->SetBinContent(1527,0.8526707);
  hrf->SetBinContent(1528,0.8628933);
  hrf->SetBinContent(1529,0.7811331);
  hrf->SetBinContent(1530,0.8275476);
  hrf->SetBinContent(1531,0.8609779);
  hrf->SetBinContent(1532,0.8738233);
  hrf->SetBinContent(1533,2);
  hrf->SetBinContent(1534,1.538174e-08);
  hrf->SetBinContent(1535,0.8223987);
  hrf->SetBinContent(1536,0.8590292);
  hrf->SetBinContent(1537,0.8364939);
  hrf->SetBinContent(1538,0.8625243);
  hrf->SetBinContent(1539,0.7879927);
  hrf->SetBinContent(1540,0.8329675);
  hrf->SetBinContent(1541,0.8196524);
  hrf->SetBinContent(1542,0.889112);
  hrf->SetBinContent(1543,0.9101152);
  hrf->SetBinContent(1544,0.7899218);
  hrf->SetBinContent(1545,0.8052071);
  hrf->SetBinContent(1546,0.4351703);
  hrf->SetBinContent(1547,0.8065562);
  hrf->SetBinContent(1548,0.8227643);
  hrf->SetBinContent(1549,0.8074349);
  hrf->SetBinContent(1550,0.8329206);
  hrf->SetBinContent(1551,0.7967104);
  hrf->SetBinContent(1552,0.7832514);
  hrf->SetBinContent(1553,0.768122);
  hrf->SetBinContent(1554,0.814672);
  hrf->SetBinContent(1555,0.7814745);
  hrf->SetBinContent(1556,0.8296988);
  hrf->SetBinContent(1557,0.8460507);
  hrf->SetBinContent(1558,0.8453766);
  hrf->SetBinContent(1559,1.394065);
  hrf->SetBinContent(1560,0.8195785);
  hrf->SetBinContent(1561,0.8590771);
  hrf->SetBinContent(1562,0.7999985);
  hrf->SetBinContent(1563,0.8421693);
  hrf->SetBinContent(1564,0.8634927);

  return hrf;

}

// ------------ single pion response function from shower track-----

TH2D* TCMETAlgo::getResponseFunction_noshower() {
  
  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","non-shower RF (fit)",52, xAxis1,28, yAxis1);
  hrf->SetBinContent(163,0.6400471);
  hrf->SetBinContent(164,0.7197217);
  hrf->SetBinContent(165,0.7705277);
  hrf->SetBinContent(166,0.7689679);
  hrf->SetBinContent(167,0.7037262);
  hrf->SetBinContent(168,0.6097692);
  hrf->SetBinContent(169,0.6026249);
  hrf->SetBinContent(170,0.4880021);
  hrf->SetBinContent(171,0.3787266);
  hrf->SetBinContent(172,0.2350156);
  hrf->SetBinContent(173,0.219073);
  hrf->SetBinContent(174,0.2191393);
  hrf->SetBinContent(175,0.2753591);
  hrf->SetBinContent(176,1.366886e-14);
  hrf->SetBinContent(177,3.453943e-15);
  hrf->SetBinContent(178,1.380731e-16);
  hrf->SetBinContent(179,3.279169e-16);
  hrf->SetBinContent(180,8.452717e-14);
  hrf->SetBinContent(181,3.328501e-17);
  hrf->SetBinContent(182,0.3409182);
  hrf->SetBinContent(183,0.4767957);
  hrf->SetBinContent(184,1.951564e-18);
  hrf->SetBinContent(185,2.900783e-15);
  hrf->SetBinContent(186,1.296576e-14);
  hrf->SetBinContent(187,2.832803e-15);
  hrf->SetBinContent(188,7.610557e-16);
  hrf->SetBinContent(189,3.546542e-13);
  hrf->SetBinContent(190,8.606939e-16);
  hrf->SetBinContent(191,8.730876e-12);
  hrf->SetBinContent(192,4.470491e-15);
  hrf->SetBinContent(193,2.456455e-13);
  hrf->SetBinContent(194,2.170573e-16);
  hrf->SetBinContent(195,0.3464883);
  hrf->SetBinContent(196,0.0206337);
  hrf->SetBinContent(197,3.021008e-12);
  hrf->SetBinContent(198,4.707796e-13);
  hrf->SetBinContent(199,4.0623e-14);
  hrf->SetBinContent(200,4.115198e-15);
  hrf->SetBinContent(201,8.337408e-13);
  hrf->SetBinContent(202,0.228919);
  hrf->SetBinContent(203,1.267038e-12);
  hrf->SetBinContent(204,2.175747e-13);
  hrf->SetBinContent(205,3.821724e-13);
  hrf->SetBinContent(206,0.1894161);
  hrf->SetBinContent(207,0.3402959);
  hrf->SetBinContent(208,0.4059051);
  hrf->SetBinContent(209,0.4614792);
  hrf->SetBinContent(210,0.5189589);
  hrf->SetBinContent(211,0.6140491);
  hrf->SetBinContent(212,0.6395754);
  hrf->SetBinContent(213,0.6345313);
  hrf->SetBinContent(214,0.5764959);
  hrf->SetBinContent(217,0.6154265);
  hrf->SetBinContent(218,0.6812514);
  hrf->SetBinContent(219,0.7334445);
  hrf->SetBinContent(220,0.752498);
  hrf->SetBinContent(221,0.7265755);
  hrf->SetBinContent(222,0.6524332);
  hrf->SetBinContent(223,0.5913962);
  hrf->SetBinContent(224,0.4738731);
  hrf->SetBinContent(225,0.3398328);
  hrf->SetBinContent(226,0.3320888);
  hrf->SetBinContent(227,0.3050285);
  hrf->SetBinContent(228,0.09497643);
  hrf->SetBinContent(229,0.01537557);
  hrf->SetBinContent(230,7.661648e-11);
  hrf->SetBinContent(231,0.1108151);
  hrf->SetBinContent(232,0.2663473);
  hrf->SetBinContent(233,0.3121616);
  hrf->SetBinContent(234,0.3571696);
  hrf->SetBinContent(235,1.152347e-13);
  hrf->SetBinContent(236,1.753052e-14);
  hrf->SetBinContent(237,1.055517e-13);
  hrf->SetBinContent(238,4.32909e-12);
  hrf->SetBinContent(239,2.708879e-16);
  hrf->SetBinContent(240,1.884276e-12);
  hrf->SetBinContent(241,1.287943e-13);
  hrf->SetBinContent(242,1.157993e-11);
  hrf->SetBinContent(243,6.523176e-13);
  hrf->SetBinContent(244,6.855802e-12);
  hrf->SetBinContent(245,3.4108e-13);
  hrf->SetBinContent(246,1.608902e-15);
  hrf->SetBinContent(247,1.088044e-12);
  hrf->SetBinContent(248,9.624121e-14);
  hrf->SetBinContent(249,6.370772e-16);
  hrf->SetBinContent(250,1.301799e-12);
  hrf->SetBinContent(251,0.3605876);
  hrf->SetBinContent(252,0.2917439);
  hrf->SetBinContent(253,0.2356352);
  hrf->SetBinContent(254,0.00659433);
  hrf->SetBinContent(255,3.909949e-12);
  hrf->SetBinContent(256,4.166508e-14);
  hrf->SetBinContent(257,1.350189e-14);
  hrf->SetBinContent(258,1.414884e-17);
  hrf->SetBinContent(259,0.06061962);
  hrf->SetBinContent(260,0.08133564);
  hrf->SetBinContent(261,0.3266752);
  hrf->SetBinContent(262,0.4730967);
  hrf->SetBinContent(263,0.5211827);
  hrf->SetBinContent(264,0.5929002);
  hrf->SetBinContent(265,0.6360459);
  hrf->SetBinContent(266,0.6585686);
  hrf->SetBinContent(267,0.6288643);
  hrf->SetBinContent(268,0.5756851);
  hrf->SetBinContent(271,0.6387249);
  hrf->SetBinContent(272,0.677789);
  hrf->SetBinContent(273,0.7180347);
  hrf->SetBinContent(274,0.7297289);
  hrf->SetBinContent(275,0.720934);
  hrf->SetBinContent(276,0.6819276);
  hrf->SetBinContent(277,0.6652455);
  hrf->SetBinContent(278,0.6041919);
  hrf->SetBinContent(279,0.5153493);
  hrf->SetBinContent(280,0.4806414);
  hrf->SetBinContent(281,0.4495209);
  hrf->SetBinContent(282,0.4227853);
  hrf->SetBinContent(283,0.3837889);
  hrf->SetBinContent(284,0.341496);
  hrf->SetBinContent(285,0.3296164);
  hrf->SetBinContent(286,0.3421705);
  hrf->SetBinContent(287,0.360976);
  hrf->SetBinContent(288,0.3551224);
  hrf->SetBinContent(289,0.3728781);
  hrf->SetBinContent(290,0.3965779);
  hrf->SetBinContent(291,0.4305746);
  hrf->SetBinContent(292,0.4374409);
  hrf->SetBinContent(293,0.4483791);
  hrf->SetBinContent(294,0.4764922);
  hrf->SetBinContent(295,0.4992606);
  hrf->SetBinContent(296,0.5098206);
  hrf->SetBinContent(297,0.4798357);
  hrf->SetBinContent(298,0.4897116);
  hrf->SetBinContent(299,0.4734376);
  hrf->SetBinContent(300,0.4570703);
  hrf->SetBinContent(301,0.3906605);
  hrf->SetBinContent(302,0.3914719);
  hrf->SetBinContent(303,0.3596696);
  hrf->SetBinContent(304,0.3133957);
  hrf->SetBinContent(305,0.3382987);
  hrf->SetBinContent(306,0.3336977);
  hrf->SetBinContent(307,0.3240096);
  hrf->SetBinContent(308,0.3258908);
  hrf->SetBinContent(309,0.3156744);
  hrf->SetBinContent(310,0.3435096);
  hrf->SetBinContent(311,0.363777);
  hrf->SetBinContent(312,0.384053);
  hrf->SetBinContent(313,0.3947456);
  hrf->SetBinContent(314,0.4252563);
  hrf->SetBinContent(315,0.499156);
  hrf->SetBinContent(316,0.5335806);
  hrf->SetBinContent(317,0.5937738);
  hrf->SetBinContent(318,0.6133472);
  hrf->SetBinContent(319,0.6376735);
  hrf->SetBinContent(320,0.6410248);
  hrf->SetBinContent(321,0.6319933);
  hrf->SetBinContent(322,0.6076105);
  hrf->SetBinContent(325,0.695102);
  hrf->SetBinContent(326,0.7317864);
  hrf->SetBinContent(327,0.7151045);
  hrf->SetBinContent(328,0.7259061);
  hrf->SetBinContent(329,0.7057022);
  hrf->SetBinContent(330,0.6724814);
  hrf->SetBinContent(331,0.6533089);
  hrf->SetBinContent(332,0.6532331);
  hrf->SetBinContent(333,0.6235004);
  hrf->SetBinContent(334,0.572711);
  hrf->SetBinContent(335,0.5225867);
  hrf->SetBinContent(336,0.5148557);
  hrf->SetBinContent(337,0.4962895);
  hrf->SetBinContent(338,0.4901881);
  hrf->SetBinContent(339,0.468125);
  hrf->SetBinContent(340,0.4836966);
  hrf->SetBinContent(341,0.4867525);
  hrf->SetBinContent(342,0.4971446);
  hrf->SetBinContent(343,0.5154772);
  hrf->SetBinContent(344,0.5200015);
  hrf->SetBinContent(345,0.5336372);
  hrf->SetBinContent(346,0.5606785);
  hrf->SetBinContent(347,0.5553446);
  hrf->SetBinContent(348,0.5552243);
  hrf->SetBinContent(349,0.5668997);
  hrf->SetBinContent(350,0.5681084);
  hrf->SetBinContent(351,0.5711104);
  hrf->SetBinContent(352,0.5574954);
  hrf->SetBinContent(353,0.5491828);
  hrf->SetBinContent(354,0.5546041);
  hrf->SetBinContent(355,0.5383464);
  hrf->SetBinContent(356,0.5327404);
  hrf->SetBinContent(357,0.4987473);
  hrf->SetBinContent(358,0.4961591);
  hrf->SetBinContent(359,0.5059707);
  hrf->SetBinContent(360,0.5101573);
  hrf->SetBinContent(361,0.469202);
  hrf->SetBinContent(362,0.4601543);
  hrf->SetBinContent(363,0.4857516);
  hrf->SetBinContent(364,0.4750769);
  hrf->SetBinContent(365,0.4731531);
  hrf->SetBinContent(366,0.4951779);
  hrf->SetBinContent(367,0.5101241);
  hrf->SetBinContent(368,0.5601708);
  hrf->SetBinContent(369,0.5669625);
  hrf->SetBinContent(370,0.5919175);
  hrf->SetBinContent(371,0.6129183);
  hrf->SetBinContent(372,0.6149203);
  hrf->SetBinContent(373,0.6737269);
  hrf->SetBinContent(374,0.6934542);
  hrf->SetBinContent(375,0.6893013);
  hrf->SetBinContent(376,0.6782404);
  hrf->SetBinContent(379,0.7620484);
  hrf->SetBinContent(380,0.7767984);
  hrf->SetBinContent(381,0.768586);
  hrf->SetBinContent(382,0.7613204);
  hrf->SetBinContent(383,0.7180475);
  hrf->SetBinContent(384,0.6963158);
  hrf->SetBinContent(385,0.6779983);
  hrf->SetBinContent(386,0.6694171);
  hrf->SetBinContent(387,0.6588553);
  hrf->SetBinContent(388,0.5652842);
  hrf->SetBinContent(389,0.5554783);
  hrf->SetBinContent(390,0.5424839);
  hrf->SetBinContent(391,0.5428849);
  hrf->SetBinContent(392,0.5169798);
  hrf->SetBinContent(393,0.5124087);
  hrf->SetBinContent(394,0.5164254);
  hrf->SetBinContent(395,0.528432);
  hrf->SetBinContent(396,0.5428852);
  hrf->SetBinContent(397,0.5517648);
  hrf->SetBinContent(398,0.5576946);
  hrf->SetBinContent(399,0.5750021);
  hrf->SetBinContent(400,0.6002611);
  hrf->SetBinContent(401,0.5966565);
  hrf->SetBinContent(402,0.5943705);
  hrf->SetBinContent(403,0.6145469);
  hrf->SetBinContent(404,0.607985);
  hrf->SetBinContent(405,0.6166915);
  hrf->SetBinContent(406,0.5980629);
  hrf->SetBinContent(407,0.5841091);
  hrf->SetBinContent(408,0.5817078);
  hrf->SetBinContent(409,0.5839701);
  hrf->SetBinContent(410,0.5622407);
  hrf->SetBinContent(411,0.5501884);
  hrf->SetBinContent(412,0.5395579);
  hrf->SetBinContent(413,0.5392244);
  hrf->SetBinContent(414,0.5121037);
  hrf->SetBinContent(415,0.5086905);
  hrf->SetBinContent(416,0.5099881);
  hrf->SetBinContent(417,0.5213704);
  hrf->SetBinContent(418,0.518967);
  hrf->SetBinContent(419,0.5217742);
  hrf->SetBinContent(420,0.5308712);
  hrf->SetBinContent(421,0.533509);
  hrf->SetBinContent(422,0.6000783);
  hrf->SetBinContent(423,0.6004054);
  hrf->SetBinContent(424,0.618421);
  hrf->SetBinContent(425,0.6403746);
  hrf->SetBinContent(426,0.6749609);
  hrf->SetBinContent(427,0.7049621);
  hrf->SetBinContent(428,0.7251113);
  hrf->SetBinContent(429,0.746736);
  hrf->SetBinContent(430,0.7463733);
  hrf->SetBinContent(433,0.7768439);
  hrf->SetBinContent(434,0.7947442);
  hrf->SetBinContent(435,0.7912208);
  hrf->SetBinContent(436,0.7809728);
  hrf->SetBinContent(437,0.7551434);
  hrf->SetBinContent(438,0.7318185);
  hrf->SetBinContent(439,0.7093385);
  hrf->SetBinContent(440,0.678341);
  hrf->SetBinContent(441,0.6670629);
  hrf->SetBinContent(442,0.5887975);
  hrf->SetBinContent(443,0.5729458);
  hrf->SetBinContent(444,0.5542971);
  hrf->SetBinContent(445,0.5496716);
  hrf->SetBinContent(446,0.5606599);
  hrf->SetBinContent(447,0.5490948);
  hrf->SetBinContent(448,0.5593737);
  hrf->SetBinContent(449,0.5700086);
  hrf->SetBinContent(450,0.5800818);
  hrf->SetBinContent(451,0.5875502);
  hrf->SetBinContent(452,0.5939422);
  hrf->SetBinContent(453,0.6040691);
  hrf->SetBinContent(454,0.6150405);
  hrf->SetBinContent(455,0.6234732);
  hrf->SetBinContent(456,0.6227227);
  hrf->SetBinContent(457,0.6343882);
  hrf->SetBinContent(458,0.6272793);
  hrf->SetBinContent(459,0.632639);
  hrf->SetBinContent(460,0.6219652);
  hrf->SetBinContent(461,0.6143699);
  hrf->SetBinContent(462,0.6189308);
  hrf->SetBinContent(463,0.6092473);
  hrf->SetBinContent(464,0.5857328);
  hrf->SetBinContent(465,0.585558);
  hrf->SetBinContent(466,0.5719752);
  hrf->SetBinContent(467,0.5688713);
  hrf->SetBinContent(468,0.5660589);
  hrf->SetBinContent(469,0.5587242);
  hrf->SetBinContent(470,0.5392494);
  hrf->SetBinContent(471,0.5389499);
  hrf->SetBinContent(472,0.54435);
  hrf->SetBinContent(473,0.5380881);
  hrf->SetBinContent(474,0.5513711);
  hrf->SetBinContent(475,0.5579215);
  hrf->SetBinContent(476,0.6440697);
  hrf->SetBinContent(477,0.6357275);
  hrf->SetBinContent(478,0.6576046);
  hrf->SetBinContent(479,0.6791567);
  hrf->SetBinContent(480,0.720274);
  hrf->SetBinContent(481,0.7455162);
  hrf->SetBinContent(482,0.7641031);
  hrf->SetBinContent(483,0.7731579);
  hrf->SetBinContent(484,0.7527794);
  hrf->SetBinContent(487,0.7882684);
  hrf->SetBinContent(488,0.8060328);
  hrf->SetBinContent(489,0.822098);
  hrf->SetBinContent(490,0.8099838);
  hrf->SetBinContent(491,0.7939186);
  hrf->SetBinContent(492,0.7642311);
  hrf->SetBinContent(493,0.7266155);
  hrf->SetBinContent(494,0.7093141);
  hrf->SetBinContent(495,0.7159176);
  hrf->SetBinContent(496,0.6176301);
  hrf->SetBinContent(497,0.5909266);
  hrf->SetBinContent(498,0.5775011);
  hrf->SetBinContent(499,0.5636105);
  hrf->SetBinContent(500,0.5605077);
  hrf->SetBinContent(501,0.5591629);
  hrf->SetBinContent(502,0.572946);
  hrf->SetBinContent(503,0.588539);
  hrf->SetBinContent(504,0.6028153);
  hrf->SetBinContent(505,0.6043608);
  hrf->SetBinContent(506,0.6062418);
  hrf->SetBinContent(507,0.6114499);
  hrf->SetBinContent(508,0.638523);
  hrf->SetBinContent(509,0.6267287);
  hrf->SetBinContent(510,0.645672);
  hrf->SetBinContent(511,0.6506661);
  hrf->SetBinContent(512,0.6475296);
  hrf->SetBinContent(513,0.6484878);
  hrf->SetBinContent(514,0.6513461);
  hrf->SetBinContent(515,0.6442053);
  hrf->SetBinContent(516,0.63371);
  hrf->SetBinContent(517,0.6322624);
  hrf->SetBinContent(518,0.6110942);
  hrf->SetBinContent(519,0.6043542);
  hrf->SetBinContent(520,0.6015413);
  hrf->SetBinContent(521,0.6036028);
  hrf->SetBinContent(522,0.5700738);
  hrf->SetBinContent(523,0.5581338);
  hrf->SetBinContent(524,0.5535045);
  hrf->SetBinContent(525,0.5559112);
  hrf->SetBinContent(526,0.5493221);
  hrf->SetBinContent(527,0.5585357);
  hrf->SetBinContent(528,0.5609397);
  hrf->SetBinContent(529,0.5869038);
  hrf->SetBinContent(530,0.6756232);
  hrf->SetBinContent(531,0.6767399);
  hrf->SetBinContent(532,0.674344);
  hrf->SetBinContent(533,0.7147918);
  hrf->SetBinContent(534,0.7455071);
  hrf->SetBinContent(535,0.7640942);
  hrf->SetBinContent(536,0.7841354);
  hrf->SetBinContent(537,0.7800902);
  hrf->SetBinContent(538,0.7629985);
  hrf->SetBinContent(541,0.7825245);
  hrf->SetBinContent(542,0.8104852);
  hrf->SetBinContent(543,0.8185261);
  hrf->SetBinContent(544,0.8149938);
  hrf->SetBinContent(545,0.8051406);
  hrf->SetBinContent(546,0.7840108);
  hrf->SetBinContent(547,0.7692546);
  hrf->SetBinContent(548,0.7316672);
  hrf->SetBinContent(549,0.7493926);
  hrf->SetBinContent(550,0.6496075);
  hrf->SetBinContent(551,0.61375);
  hrf->SetBinContent(552,0.5973386);
  hrf->SetBinContent(553,0.5833439);
  hrf->SetBinContent(554,0.5823619);
  hrf->SetBinContent(555,0.575554);
  hrf->SetBinContent(556,0.5877919);
  hrf->SetBinContent(557,0.6007444);
  hrf->SetBinContent(558,0.6090866);
  hrf->SetBinContent(559,0.6100489);
  hrf->SetBinContent(560,0.6170378);
  hrf->SetBinContent(561,0.6346263);
  hrf->SetBinContent(562,0.6551198);
  hrf->SetBinContent(563,0.6504108);
  hrf->SetBinContent(564,0.6529323);
  hrf->SetBinContent(565,0.6615734);
  hrf->SetBinContent(566,0.6708243);
  hrf->SetBinContent(567,0.6619729);
  hrf->SetBinContent(568,0.6477604);
  hrf->SetBinContent(569,0.6553877);
  hrf->SetBinContent(570,0.6341878);
  hrf->SetBinContent(571,0.6327103);
  hrf->SetBinContent(572,0.6286492);
  hrf->SetBinContent(573,0.6085496);
  hrf->SetBinContent(574,0.6167193);
  hrf->SetBinContent(575,0.6131056);
  hrf->SetBinContent(576,0.5831536);
  hrf->SetBinContent(577,0.5811253);
  hrf->SetBinContent(578,0.5723613);
  hrf->SetBinContent(579,0.572602);
  hrf->SetBinContent(580,0.5616767);
  hrf->SetBinContent(581,0.5828878);
  hrf->SetBinContent(582,0.6059858);
  hrf->SetBinContent(583,0.6168311);
  hrf->SetBinContent(584,0.7131738);
  hrf->SetBinContent(585,0.7072036);
  hrf->SetBinContent(586,0.7213496);
  hrf->SetBinContent(587,0.7446843);
  hrf->SetBinContent(588,0.7663606);
  hrf->SetBinContent(589,0.789193);
  hrf->SetBinContent(590,0.788421);
  hrf->SetBinContent(591,0.792608);
  hrf->SetBinContent(592,0.7788052);
  hrf->SetBinContent(595,0.7937253);
  hrf->SetBinContent(596,0.8081693);
  hrf->SetBinContent(597,0.8123267);
  hrf->SetBinContent(598,0.8186647);
  hrf->SetBinContent(599,0.8086275);
  hrf->SetBinContent(600,0.7988818);
  hrf->SetBinContent(601,0.7764101);
  hrf->SetBinContent(602,0.7557399);
  hrf->SetBinContent(603,0.761918);
  hrf->SetBinContent(604,0.6849239);
  hrf->SetBinContent(605,0.6502788);
  hrf->SetBinContent(606,0.6258788);
  hrf->SetBinContent(607,0.599966);
  hrf->SetBinContent(608,0.6106513);
  hrf->SetBinContent(609,0.5952777);
  hrf->SetBinContent(610,0.6028936);
  hrf->SetBinContent(611,0.6079224);
  hrf->SetBinContent(612,0.6182185);
  hrf->SetBinContent(613,0.6233015);
  hrf->SetBinContent(614,0.635029);
  hrf->SetBinContent(615,0.6358883);
  hrf->SetBinContent(616,0.6600642);
  hrf->SetBinContent(617,0.6560737);
  hrf->SetBinContent(618,0.6716946);
  hrf->SetBinContent(619,0.6668878);
  hrf->SetBinContent(620,0.6739189);
  hrf->SetBinContent(621,0.67208);
  hrf->SetBinContent(622,0.6692014);
  hrf->SetBinContent(623,0.655094);
  hrf->SetBinContent(624,0.6634452);
  hrf->SetBinContent(625,0.6670687);
  hrf->SetBinContent(626,0.6318665);
  hrf->SetBinContent(627,0.625158);
  hrf->SetBinContent(628,0.6202428);
  hrf->SetBinContent(629,0.615028);
  hrf->SetBinContent(630,0.5908931);
  hrf->SetBinContent(631,0.5965393);
  hrf->SetBinContent(632,0.5950192);
  hrf->SetBinContent(633,0.5927112);
  hrf->SetBinContent(634,0.591261);
  hrf->SetBinContent(635,0.6102637);
  hrf->SetBinContent(636,0.6186118);
  hrf->SetBinContent(637,0.6456433);
  hrf->SetBinContent(638,0.730924);
  hrf->SetBinContent(639,0.7337946);
  hrf->SetBinContent(640,0.7463949);
  hrf->SetBinContent(641,0.7606013);
  hrf->SetBinContent(642,0.7666355);
  hrf->SetBinContent(643,0.7872874);
  hrf->SetBinContent(644,0.8022897);
  hrf->SetBinContent(645,0.7985926);
  hrf->SetBinContent(646,0.783218);
  hrf->SetBinContent(649,0.7833578);
  hrf->SetBinContent(650,0.8143964);
  hrf->SetBinContent(651,0.8124664);
  hrf->SetBinContent(652,0.8186299);
  hrf->SetBinContent(653,0.8080379);
  hrf->SetBinContent(654,0.798955);
  hrf->SetBinContent(655,0.7926162);
  hrf->SetBinContent(656,0.7792218);
  hrf->SetBinContent(657,0.7937103);
  hrf->SetBinContent(658,0.6792807);
  hrf->SetBinContent(659,0.6521104);
  hrf->SetBinContent(660,0.6379001);
  hrf->SetBinContent(661,0.6214611);
  hrf->SetBinContent(662,0.6116367);
  hrf->SetBinContent(663,0.6241148);
  hrf->SetBinContent(664,0.6239313);
  hrf->SetBinContent(665,0.6303791);
  hrf->SetBinContent(666,0.6271608);
  hrf->SetBinContent(667,0.6191924);
  hrf->SetBinContent(668,0.6274444);
  hrf->SetBinContent(669,0.6410729);
  hrf->SetBinContent(670,0.6506072);
  hrf->SetBinContent(671,0.6596943);
  hrf->SetBinContent(672,0.6771609);
  hrf->SetBinContent(673,0.6872007);
  hrf->SetBinContent(674,0.6858186);
  hrf->SetBinContent(675,0.6733634);
  hrf->SetBinContent(676,0.6770326);
  hrf->SetBinContent(677,0.6721333);
  hrf->SetBinContent(678,0.6590305);
  hrf->SetBinContent(679,0.6456032);
  hrf->SetBinContent(680,0.6410897);
  hrf->SetBinContent(681,0.6299676);
  hrf->SetBinContent(682,0.6255311);
  hrf->SetBinContent(683,0.6248432);
  hrf->SetBinContent(684,0.6123951);
  hrf->SetBinContent(685,0.6165767);
  hrf->SetBinContent(686,0.6150315);
  hrf->SetBinContent(687,0.6173973);
  hrf->SetBinContent(688,0.6240689);
  hrf->SetBinContent(689,0.6187074);
  hrf->SetBinContent(690,0.6461738);
  hrf->SetBinContent(691,0.6547161);
  hrf->SetBinContent(692,0.7550126);
  hrf->SetBinContent(693,0.7437691);
  hrf->SetBinContent(694,0.7466658);
  hrf->SetBinContent(695,0.7647577);
  hrf->SetBinContent(696,0.775592);
  hrf->SetBinContent(697,0.8015463);
  hrf->SetBinContent(698,0.796218);
  hrf->SetBinContent(699,0.7938139);
  hrf->SetBinContent(700,0.7877747);
  hrf->SetBinContent(703,0.7938337);
  hrf->SetBinContent(704,0.8112386);
  hrf->SetBinContent(705,0.8210182);
  hrf->SetBinContent(706,0.8071941);
  hrf->SetBinContent(707,0.8099721);
  hrf->SetBinContent(708,0.8184054);
  hrf->SetBinContent(709,0.7795862);
  hrf->SetBinContent(710,0.781167);
  hrf->SetBinContent(711,0.8112692);
  hrf->SetBinContent(712,0.7050076);
  hrf->SetBinContent(713,0.6961941);
  hrf->SetBinContent(714,0.6431594);
  hrf->SetBinContent(715,0.6518742);
  hrf->SetBinContent(716,0.6676597);
  hrf->SetBinContent(717,0.6348912);
  hrf->SetBinContent(718,0.6320897);
  hrf->SetBinContent(719,0.6619865);
  hrf->SetBinContent(720,0.6408801);
  hrf->SetBinContent(721,0.6611646);
  hrf->SetBinContent(722,0.6469863);
  hrf->SetBinContent(723,0.6624107);
  hrf->SetBinContent(724,0.6726641);
  hrf->SetBinContent(725,0.6769128);
  hrf->SetBinContent(726,0.6586064);
  hrf->SetBinContent(727,0.6795991);
  hrf->SetBinContent(728,0.6835785);
  hrf->SetBinContent(729,0.6803078);
  hrf->SetBinContent(730,0.6512326);
  hrf->SetBinContent(731,0.6668034);
  hrf->SetBinContent(732,0.6699911);
  hrf->SetBinContent(733,0.6659495);
  hrf->SetBinContent(734,0.656548);
  hrf->SetBinContent(735,0.6311177);
  hrf->SetBinContent(736,0.6385864);
  hrf->SetBinContent(737,0.6526698);
  hrf->SetBinContent(738,0.639952);
  hrf->SetBinContent(739,0.6367444);
  hrf->SetBinContent(740,0.6429572);
  hrf->SetBinContent(741,0.6484692);
  hrf->SetBinContent(742,0.6525394);
  hrf->SetBinContent(743,0.6626204);
  hrf->SetBinContent(744,0.6566104);
  hrf->SetBinContent(745,0.6963196);
  hrf->SetBinContent(746,0.7744267);
  hrf->SetBinContent(747,0.7619394);
  hrf->SetBinContent(748,0.7550142);
  hrf->SetBinContent(749,0.7694419);
  hrf->SetBinContent(750,0.7913394);
  hrf->SetBinContent(751,0.7817686);
  hrf->SetBinContent(752,0.8011637);
  hrf->SetBinContent(753,0.8001197);
  hrf->SetBinContent(754,0.7766893);
  hrf->SetBinContent(757,0.820311);
  hrf->SetBinContent(758,0.8292386);
  hrf->SetBinContent(759,0.8256704);
  hrf->SetBinContent(760,0.829048);
  hrf->SetBinContent(761,0.8125483);
  hrf->SetBinContent(762,0.7970028);
  hrf->SetBinContent(763,0.7941346);
  hrf->SetBinContent(764,0.7978353);
  hrf->SetBinContent(765,0.8145937);
  hrf->SetBinContent(766,0.7018598);
  hrf->SetBinContent(767,0.7004585);
  hrf->SetBinContent(768,0.7196865);
  hrf->SetBinContent(769,0.6887961);
  hrf->SetBinContent(770,0.6803226);
  hrf->SetBinContent(771,0.6630092);
  hrf->SetBinContent(772,0.6932864);
  hrf->SetBinContent(773,0.706134);
  hrf->SetBinContent(774,0.696236);
  hrf->SetBinContent(775,0.6888376);
  hrf->SetBinContent(776,0.6966027);
  hrf->SetBinContent(777,0.6895446);
  hrf->SetBinContent(778,0.7041351);
  hrf->SetBinContent(779,0.6794392);
  hrf->SetBinContent(780,0.7072135);
  hrf->SetBinContent(781,0.7116039);
  hrf->SetBinContent(782,0.6892277);
  hrf->SetBinContent(783,0.706095);
  hrf->SetBinContent(784,0.6947418);
  hrf->SetBinContent(785,0.6904655);
  hrf->SetBinContent(786,0.7099751);
  hrf->SetBinContent(787,0.6884425);
  hrf->SetBinContent(788,0.6930832);
  hrf->SetBinContent(789,0.6803646);
  hrf->SetBinContent(790,0.6844568);
  hrf->SetBinContent(791,0.7109603);
  hrf->SetBinContent(792,0.6615306);
  hrf->SetBinContent(793,0.6706332);
  hrf->SetBinContent(794,0.6790296);
  hrf->SetBinContent(795,0.6676587);
  hrf->SetBinContent(796,0.6811136);
  hrf->SetBinContent(797,0.6759658);
  hrf->SetBinContent(798,0.674715);
  hrf->SetBinContent(799,0.6981677);
  hrf->SetBinContent(800,0.8118564);
  hrf->SetBinContent(801,0.7796713);
  hrf->SetBinContent(802,0.763272);
  hrf->SetBinContent(803,0.802313);
  hrf->SetBinContent(804,0.7997385);
  hrf->SetBinContent(805,0.8228589);
  hrf->SetBinContent(806,0.8193119);
  hrf->SetBinContent(807,0.8061456);
  hrf->SetBinContent(808,0.8093062);
  hrf->SetBinContent(811,0.8216234);
  hrf->SetBinContent(812,0.8354314);
  hrf->SetBinContent(813,0.8415214);
  hrf->SetBinContent(814,0.8391747);
  hrf->SetBinContent(815,0.8323319);
  hrf->SetBinContent(816,0.8270521);
  hrf->SetBinContent(817,0.8224217);
  hrf->SetBinContent(818,0.8044508);
  hrf->SetBinContent(819,0.8186831);
  hrf->SetBinContent(820,0.7421715);
  hrf->SetBinContent(821,0.7278701);
  hrf->SetBinContent(822,0.7248921);
  hrf->SetBinContent(823,0.7085358);
  hrf->SetBinContent(824,0.7273098);
  hrf->SetBinContent(825,0.7099549);
  hrf->SetBinContent(826,0.7194818);
  hrf->SetBinContent(827,0.7102996);
  hrf->SetBinContent(828,0.7120496);
  hrf->SetBinContent(829,0.6897885);
  hrf->SetBinContent(830,0.7198567);
  hrf->SetBinContent(831,0.7074706);
  hrf->SetBinContent(832,0.7436482);
  hrf->SetBinContent(833,0.7269113);
  hrf->SetBinContent(834,0.7285385);
  hrf->SetBinContent(835,0.7222486);
  hrf->SetBinContent(836,0.7284775);
  hrf->SetBinContent(837,0.7315693);
  hrf->SetBinContent(838,0.7165666);
  hrf->SetBinContent(839,0.7153305);
  hrf->SetBinContent(840,0.7235847);
  hrf->SetBinContent(841,0.7258299);
  hrf->SetBinContent(842,0.6954121);
  hrf->SetBinContent(843,0.7152382);
  hrf->SetBinContent(844,0.7054994);
  hrf->SetBinContent(845,0.7109909);
  hrf->SetBinContent(846,0.7096459);
  hrf->SetBinContent(847,0.7089959);
  hrf->SetBinContent(848,0.7104192);
  hrf->SetBinContent(849,0.7059513);
  hrf->SetBinContent(850,0.7137704);
  hrf->SetBinContent(851,0.6904989);
  hrf->SetBinContent(852,0.6933109);
  hrf->SetBinContent(853,0.6949823);
  hrf->SetBinContent(854,0.8213119);
  hrf->SetBinContent(855,0.7834505);
  hrf->SetBinContent(856,0.7924478);
  hrf->SetBinContent(857,0.8016196);
  hrf->SetBinContent(858,0.8097603);
  hrf->SetBinContent(859,0.8196169);
  hrf->SetBinContent(860,0.8230559);
  hrf->SetBinContent(861,0.8199641);
  hrf->SetBinContent(862,0.8192365);
  hrf->SetBinContent(865,0.8382419);
  hrf->SetBinContent(866,0.845595);
  hrf->SetBinContent(867,0.8503338);
  hrf->SetBinContent(868,0.8361135);
  hrf->SetBinContent(869,0.8315856);
  hrf->SetBinContent(870,0.8295157);
  hrf->SetBinContent(871,0.8086463);
  hrf->SetBinContent(872,0.8109902);
  hrf->SetBinContent(873,0.8548921);
  hrf->SetBinContent(874,0.7384512);
  hrf->SetBinContent(875,0.7409762);
  hrf->SetBinContent(876,0.7325699);
  hrf->SetBinContent(877,0.7097699);
  hrf->SetBinContent(878,0.7247443);
  hrf->SetBinContent(879,0.7235974);
  hrf->SetBinContent(880,0.7174981);
  hrf->SetBinContent(881,0.7266588);
  hrf->SetBinContent(882,0.7376115);
  hrf->SetBinContent(883,0.7187032);
  hrf->SetBinContent(884,0.7486984);
  hrf->SetBinContent(885,0.7418073);
  hrf->SetBinContent(886,0.7484841);
  hrf->SetBinContent(887,0.751286);
  hrf->SetBinContent(888,0.7288724);
  hrf->SetBinContent(889,0.7500471);
  hrf->SetBinContent(890,0.7496704);
  hrf->SetBinContent(891,0.7595446);
  hrf->SetBinContent(892,0.7479168);
  hrf->SetBinContent(893,0.728943);
  hrf->SetBinContent(894,0.7336915);
  hrf->SetBinContent(895,0.7499863);
  hrf->SetBinContent(896,0.7286334);
  hrf->SetBinContent(897,0.7333577);
  hrf->SetBinContent(898,0.7461608);
  hrf->SetBinContent(899,0.7439096);
  hrf->SetBinContent(900,0.7328548);
  hrf->SetBinContent(901,0.7203813);
  hrf->SetBinContent(902,0.7064649);
  hrf->SetBinContent(903,0.7314181);
  hrf->SetBinContent(904,0.7103841);
  hrf->SetBinContent(905,0.7173302);
  hrf->SetBinContent(906,0.7135867);
  hrf->SetBinContent(907,0.741744);
  hrf->SetBinContent(908,0.818104);
  hrf->SetBinContent(909,0.8024629);
  hrf->SetBinContent(910,0.7906242);
  hrf->SetBinContent(911,0.8110136);
  hrf->SetBinContent(912,0.8172796);
  hrf->SetBinContent(913,0.8291269);
  hrf->SetBinContent(914,0.8308977);
  hrf->SetBinContent(915,0.8352684);
  hrf->SetBinContent(916,0.8211952);
  hrf->SetBinContent(919,0.8330466);
  hrf->SetBinContent(920,0.8527036);
  hrf->SetBinContent(921,0.8498238);
  hrf->SetBinContent(922,0.827491);
  hrf->SetBinContent(923,0.8453093);
  hrf->SetBinContent(924,0.8489227);
  hrf->SetBinContent(925,0.8275191);
  hrf->SetBinContent(926,0.8346153);
  hrf->SetBinContent(927,0.8487738);
  hrf->SetBinContent(928,0.742582);
  hrf->SetBinContent(929,0.7093365);
  hrf->SetBinContent(930,0.7261602);
  hrf->SetBinContent(931,0.7267539);
  hrf->SetBinContent(932,0.73264);
  hrf->SetBinContent(933,0.7330359);
  hrf->SetBinContent(934,0.7598708);
  hrf->SetBinContent(935,0.7562078);
  hrf->SetBinContent(936,0.7556384);
  hrf->SetBinContent(937,0.7403131);
  hrf->SetBinContent(938,0.7492656);
  hrf->SetBinContent(939,0.7432143);
  hrf->SetBinContent(940,0.7788419);
  hrf->SetBinContent(941,0.7632285);
  hrf->SetBinContent(942,0.7679126);
  hrf->SetBinContent(943,0.763468);
  hrf->SetBinContent(944,0.777601);
  hrf->SetBinContent(945,0.7735646);
  hrf->SetBinContent(946,0.7563925);
  hrf->SetBinContent(947,0.7574112);
  hrf->SetBinContent(948,0.7594496);
  hrf->SetBinContent(949,0.7542186);
  hrf->SetBinContent(950,0.7722836);
  hrf->SetBinContent(951,0.7630916);
  hrf->SetBinContent(952,0.7554187);
  hrf->SetBinContent(953,0.7640414);
  hrf->SetBinContent(954,0.7528413);
  hrf->SetBinContent(955,0.7536849);
  hrf->SetBinContent(956,0.7522911);
  hrf->SetBinContent(957,0.7423979);
  hrf->SetBinContent(958,0.708038);
  hrf->SetBinContent(959,0.7218878);
  hrf->SetBinContent(960,0.7022091);
  hrf->SetBinContent(961,0.7171525);
  hrf->SetBinContent(962,0.8275716);
  hrf->SetBinContent(963,0.8115073);
  hrf->SetBinContent(964,0.8072334);
  hrf->SetBinContent(965,0.821391);
  hrf->SetBinContent(966,0.8269891);
  hrf->SetBinContent(967,0.819416);
  hrf->SetBinContent(968,0.8243529);
  hrf->SetBinContent(969,0.8403612);
  hrf->SetBinContent(970,0.8189063);
  hrf->SetBinContent(973,0.8403836);
  hrf->SetBinContent(974,0.8490381);
  hrf->SetBinContent(975,0.8456935);
  hrf->SetBinContent(976,0.8505681);
  hrf->SetBinContent(977,0.8546844);
  hrf->SetBinContent(978,0.8301553);
  hrf->SetBinContent(979,0.8285958);
  hrf->SetBinContent(980,0.8272412);
  hrf->SetBinContent(981,0.8588659);
  hrf->SetBinContent(982,0.772503);
  hrf->SetBinContent(983,0.725534);
  hrf->SetBinContent(984,0.7240637);
  hrf->SetBinContent(985,0.7158327);
  hrf->SetBinContent(986,0.7553988);
  hrf->SetBinContent(987,0.7408262);
  hrf->SetBinContent(988,0.7482234);
  hrf->SetBinContent(989,0.7603509);
  hrf->SetBinContent(990,0.7626927);
  hrf->SetBinContent(991,0.7681577);
  hrf->SetBinContent(992,0.7773151);
  hrf->SetBinContent(993,0.783787);
  hrf->SetBinContent(994,0.8194669);
  hrf->SetBinContent(995,0.7892821);
  hrf->SetBinContent(996,0.7875675);
  hrf->SetBinContent(997,0.8082216);
  hrf->SetBinContent(998,0.7857646);
  hrf->SetBinContent(999,0.7933624);
  hrf->SetBinContent(1000,0.7899764);
  hrf->SetBinContent(1001,0.7918435);
  hrf->SetBinContent(1002,0.7880425);
  hrf->SetBinContent(1003,0.803874);
  hrf->SetBinContent(1004,0.7770123);
  hrf->SetBinContent(1005,0.7597779);
  hrf->SetBinContent(1006,0.7721595);
  hrf->SetBinContent(1007,0.781916);
  hrf->SetBinContent(1008,0.7635601);
  hrf->SetBinContent(1009,0.7448658);
  hrf->SetBinContent(1010,0.7392351);
  hrf->SetBinContent(1011,0.750661);
  hrf->SetBinContent(1012,0.7487038);
  hrf->SetBinContent(1013,0.7231168);
  hrf->SetBinContent(1014,0.7470311);
  hrf->SetBinContent(1015,0.7612622);
  hrf->SetBinContent(1016,0.8279294);
  hrf->SetBinContent(1017,0.8297408);
  hrf->SetBinContent(1018,0.8170992);
  hrf->SetBinContent(1019,0.8319517);
  hrf->SetBinContent(1020,0.8270144);
  hrf->SetBinContent(1021,0.8398628);
  hrf->SetBinContent(1022,0.8434333);
  hrf->SetBinContent(1023,0.8495445);
  hrf->SetBinContent(1024,0.8397221);
  hrf->SetBinContent(1027,0.8584861);
  hrf->SetBinContent(1028,0.8705266);
  hrf->SetBinContent(1029,0.8648553);
  hrf->SetBinContent(1030,0.8693198);
  hrf->SetBinContent(1031,0.8604742);
  hrf->SetBinContent(1032,0.8419744);
  hrf->SetBinContent(1033,0.8488627);
  hrf->SetBinContent(1034,0.8596818);
  hrf->SetBinContent(1035,0.8761161);
  hrf->SetBinContent(1036,0.7735379);
  hrf->SetBinContent(1037,0.7636802);
  hrf->SetBinContent(1038,0.7415009);
  hrf->SetBinContent(1039,0.7392672);
  hrf->SetBinContent(1040,0.7662926);
  hrf->SetBinContent(1041,0.7740963);
  hrf->SetBinContent(1042,0.7629296);
  hrf->SetBinContent(1043,0.7746271);
  hrf->SetBinContent(1044,0.7922689);
  hrf->SetBinContent(1045,0.7945601);
  hrf->SetBinContent(1046,0.8078181);
  hrf->SetBinContent(1047,0.7982591);
  hrf->SetBinContent(1048,0.8149709);
  hrf->SetBinContent(1049,0.8178119);
  hrf->SetBinContent(1050,0.8224007);
  hrf->SetBinContent(1051,0.8259245);
  hrf->SetBinContent(1052,0.8287166);
  hrf->SetBinContent(1053,0.8284407);
  hrf->SetBinContent(1054,0.8248709);
  hrf->SetBinContent(1055,0.8112228);
  hrf->SetBinContent(1056,0.8003991);
  hrf->SetBinContent(1057,0.7915207);
  hrf->SetBinContent(1058,0.7917442);
  hrf->SetBinContent(1059,0.8076987);
  hrf->SetBinContent(1060,0.784733);
  hrf->SetBinContent(1061,0.7987387);
  hrf->SetBinContent(1062,0.7665949);
  hrf->SetBinContent(1063,0.7750866);
  hrf->SetBinContent(1064,0.7578187);
  hrf->SetBinContent(1065,0.7470792);
  hrf->SetBinContent(1066,0.7387265);
  hrf->SetBinContent(1067,0.7308708);
  hrf->SetBinContent(1068,0.7565303);
  hrf->SetBinContent(1069,0.7838886);
  hrf->SetBinContent(1070,0.8566341);
  hrf->SetBinContent(1071,0.8414668);
  hrf->SetBinContent(1072,0.8493964);
  hrf->SetBinContent(1073,0.8408482);
  hrf->SetBinContent(1074,0.8442303);
  hrf->SetBinContent(1075,0.8555998);
  hrf->SetBinContent(1076,0.8573167);
  hrf->SetBinContent(1077,0.8615545);
  hrf->SetBinContent(1078,0.8546741);
  hrf->SetBinContent(1081,0.8591975);
  hrf->SetBinContent(1082,0.8709853);
  hrf->SetBinContent(1083,0.8771328);
  hrf->SetBinContent(1084,0.8763101);
  hrf->SetBinContent(1085,0.8515683);
  hrf->SetBinContent(1086,0.8732017);
  hrf->SetBinContent(1087,0.8560926);
  hrf->SetBinContent(1088,0.8562469);
  hrf->SetBinContent(1089,0.8875264);
  hrf->SetBinContent(1090,0.7832932);
  hrf->SetBinContent(1091,0.7675187);
  hrf->SetBinContent(1092,0.7683659);
  hrf->SetBinContent(1093,0.7504796);
  hrf->SetBinContent(1094,0.7859329);
  hrf->SetBinContent(1095,0.7694483);
  hrf->SetBinContent(1096,0.7806211);
  hrf->SetBinContent(1097,0.7954605);
  hrf->SetBinContent(1098,0.8084871);
  hrf->SetBinContent(1099,0.8044314);
  hrf->SetBinContent(1100,0.7899461);
  hrf->SetBinContent(1101,0.8162944);
  hrf->SetBinContent(1102,0.8343187);
  hrf->SetBinContent(1103,0.8230114);
  hrf->SetBinContent(1104,0.812171);
  hrf->SetBinContent(1105,0.8203622);
  hrf->SetBinContent(1106,0.8227281);
  hrf->SetBinContent(1107,0.8324733);
  hrf->SetBinContent(1108,0.8200341);
  hrf->SetBinContent(1109,0.8198539);
  hrf->SetBinContent(1110,0.830998);
  hrf->SetBinContent(1111,0.8143437);
  hrf->SetBinContent(1112,0.8231221);
  hrf->SetBinContent(1113,0.8290741);
  hrf->SetBinContent(1114,0.8044104);
  hrf->SetBinContent(1115,0.8085917);
  hrf->SetBinContent(1116,0.7965005);
  hrf->SetBinContent(1117,0.7736762);
  hrf->SetBinContent(1118,0.7865528);
  hrf->SetBinContent(1119,0.7845833);
  hrf->SetBinContent(1120,0.7356455);
  hrf->SetBinContent(1121,0.7719955);
  hrf->SetBinContent(1122,0.7799032);
  hrf->SetBinContent(1123,0.7859467);
  hrf->SetBinContent(1124,0.8770262);
  hrf->SetBinContent(1125,0.847388);
  hrf->SetBinContent(1126,0.8384124);
  hrf->SetBinContent(1127,0.8508531);
  hrf->SetBinContent(1128,0.8527084);
  hrf->SetBinContent(1129,0.8647637);
  hrf->SetBinContent(1130,0.8652126);
  hrf->SetBinContent(1131,0.8690927);
  hrf->SetBinContent(1132,0.8697549);
  hrf->SetBinContent(1135,0.8678578);
  hrf->SetBinContent(1136,0.8721905);
  hrf->SetBinContent(1137,0.8771986);
  hrf->SetBinContent(1138,0.8798792);
  hrf->SetBinContent(1139,0.8788907);
  hrf->SetBinContent(1140,0.8633229);
  hrf->SetBinContent(1141,0.8740997);
  hrf->SetBinContent(1142,0.856037);
  hrf->SetBinContent(1143,0.887048);
  hrf->SetBinContent(1144,0.8030304);
  hrf->SetBinContent(1145,0.7964841);
  hrf->SetBinContent(1146,0.7718329);
  hrf->SetBinContent(1147,0.7641056);
  hrf->SetBinContent(1148,0.7686037);
  hrf->SetBinContent(1149,0.7824436);
  hrf->SetBinContent(1150,0.7878762);
  hrf->SetBinContent(1151,0.8071508);
  hrf->SetBinContent(1152,0.8079754);
  hrf->SetBinContent(1153,0.8146648);
  hrf->SetBinContent(1154,0.8261297);
  hrf->SetBinContent(1155,0.8238618);
  hrf->SetBinContent(1156,0.8342342);
  hrf->SetBinContent(1157,0.8386516);
  hrf->SetBinContent(1158,0.8238772);
  hrf->SetBinContent(1159,0.8355077);
  hrf->SetBinContent(1160,0.8530656);
  hrf->SetBinContent(1161,0.8270102);
  hrf->SetBinContent(1162,0.8280492);
  hrf->SetBinContent(1163,0.8212458);
  hrf->SetBinContent(1164,0.8266846);
  hrf->SetBinContent(1165,0.8268626);
  hrf->SetBinContent(1166,0.8331493);
  hrf->SetBinContent(1167,0.813269);
  hrf->SetBinContent(1168,0.8189407);
  hrf->SetBinContent(1169,0.803855);
  hrf->SetBinContent(1170,0.7985492);
  hrf->SetBinContent(1171,0.8035755);
  hrf->SetBinContent(1172,0.7932234);
  hrf->SetBinContent(1173,0.7919983);
  hrf->SetBinContent(1174,0.7780269);
  hrf->SetBinContent(1175,0.7745364);
  hrf->SetBinContent(1176,0.7764118);
  hrf->SetBinContent(1177,0.8024556);
  hrf->SetBinContent(1178,0.8828636);
  hrf->SetBinContent(1179,0.8603634);
  hrf->SetBinContent(1180,0.8476664);
  hrf->SetBinContent(1181,0.8649756);
  hrf->SetBinContent(1182,0.8686491);
  hrf->SetBinContent(1183,0.879);
  hrf->SetBinContent(1184,0.8710791);
  hrf->SetBinContent(1185,0.8777198);
  hrf->SetBinContent(1186,0.8720512);
  hrf->SetBinContent(1189,0.8738415);
  hrf->SetBinContent(1190,0.8861113);
  hrf->SetBinContent(1191,0.8809734);
  hrf->SetBinContent(1192,0.8953835);
  hrf->SetBinContent(1193,0.8797553);
  hrf->SetBinContent(1194,0.8663118);
  hrf->SetBinContent(1195,0.8772114);
  hrf->SetBinContent(1196,0.8705546);
  hrf->SetBinContent(1197,0.8862349);
  hrf->SetBinContent(1198,0.8061298);
  hrf->SetBinContent(1199,0.7902361);
  hrf->SetBinContent(1200,0.778208);
  hrf->SetBinContent(1201,0.7780085);
  hrf->SetBinContent(1202,0.8111438);
  hrf->SetBinContent(1203,0.7892882);
  hrf->SetBinContent(1204,0.8093601);
  hrf->SetBinContent(1205,0.8006216);
  hrf->SetBinContent(1206,0.8030534);
  hrf->SetBinContent(1207,0.8418001);
  hrf->SetBinContent(1208,0.8177408);
  hrf->SetBinContent(1209,0.836045);
  hrf->SetBinContent(1210,0.8453377);
  hrf->SetBinContent(1211,0.8403149);
  hrf->SetBinContent(1212,0.8373511);
  hrf->SetBinContent(1213,0.8503633);
  hrf->SetBinContent(1214,0.8382619);
  hrf->SetBinContent(1215,0.8430184);
  hrf->SetBinContent(1216,0.8487076);
  hrf->SetBinContent(1217,0.8495836);
  hrf->SetBinContent(1218,0.8313101);
  hrf->SetBinContent(1219,0.837076);
  hrf->SetBinContent(1220,0.835078);
  hrf->SetBinContent(1221,0.8362027);
  hrf->SetBinContent(1222,0.8226167);
  hrf->SetBinContent(1223,0.8357954);
  hrf->SetBinContent(1224,0.816876);
  hrf->SetBinContent(1225,0.8086238);
  hrf->SetBinContent(1226,0.7925934);
  hrf->SetBinContent(1227,0.7871425);
  hrf->SetBinContent(1228,0.7787439);
  hrf->SetBinContent(1229,0.7699108);
  hrf->SetBinContent(1230,0.7912937);
  hrf->SetBinContent(1231,0.8084047);
  hrf->SetBinContent(1232,0.8865966);
  hrf->SetBinContent(1233,0.8652479);
  hrf->SetBinContent(1234,0.8537798);
  hrf->SetBinContent(1235,0.86984);
  hrf->SetBinContent(1236,0.8673007);
  hrf->SetBinContent(1237,0.8768569);
  hrf->SetBinContent(1238,0.8813039);
  hrf->SetBinContent(1239,0.8832306);
  hrf->SetBinContent(1240,0.878592);
  hrf->SetBinContent(1243,0.8715378);
  hrf->SetBinContent(1244,0.8861935);
  hrf->SetBinContent(1245,0.8852835);
  hrf->SetBinContent(1246,0.8787801);
  hrf->SetBinContent(1247,0.8783889);
  hrf->SetBinContent(1248,0.8855093);
  hrf->SetBinContent(1249,0.8748751);
  hrf->SetBinContent(1250,0.8728771);
  hrf->SetBinContent(1251,0.9018467);
  hrf->SetBinContent(1252,0.8249069);
  hrf->SetBinContent(1253,0.8002755);
  hrf->SetBinContent(1254,0.7838525);
  hrf->SetBinContent(1255,0.7903357);
  hrf->SetBinContent(1256,0.7916073);
  hrf->SetBinContent(1257,0.7985547);
  hrf->SetBinContent(1258,0.8262318);
  hrf->SetBinContent(1259,0.8094212);
  hrf->SetBinContent(1260,0.8267502);
  hrf->SetBinContent(1261,0.8316746);
  hrf->SetBinContent(1262,0.8368371);
  hrf->SetBinContent(1263,0.8482142);
  hrf->SetBinContent(1264,0.8502672);
  hrf->SetBinContent(1265,0.8363052);
  hrf->SetBinContent(1266,0.8458726);
  hrf->SetBinContent(1267,0.8617958);
  hrf->SetBinContent(1268,0.8571753);
  hrf->SetBinContent(1269,0.8481821);
  hrf->SetBinContent(1270,0.8443859);
  hrf->SetBinContent(1271,0.8364177);
  hrf->SetBinContent(1272,0.8381643);
  hrf->SetBinContent(1273,0.8412254);
  hrf->SetBinContent(1274,0.8447568);
  hrf->SetBinContent(1275,0.8186399);
  hrf->SetBinContent(1276,0.8319127);
  hrf->SetBinContent(1277,0.8139984);
  hrf->SetBinContent(1278,0.8199334);
  hrf->SetBinContent(1279,0.8115138);
  hrf->SetBinContent(1280,0.801327);
  hrf->SetBinContent(1281,0.7812868);
  hrf->SetBinContent(1282,0.7778735);
  hrf->SetBinContent(1283,0.7987794);
  hrf->SetBinContent(1284,0.7824721);
  hrf->SetBinContent(1285,0.8182753);
  hrf->SetBinContent(1286,0.8761631);
  hrf->SetBinContent(1287,0.877906);
  hrf->SetBinContent(1288,0.8828306);
  hrf->SetBinContent(1289,0.8631628);
  hrf->SetBinContent(1290,0.8747018);
  hrf->SetBinContent(1291,0.8816374);
  hrf->SetBinContent(1292,0.8905643);
  hrf->SetBinContent(1293,0.8805439);
  hrf->SetBinContent(1294,0.8729373);
  hrf->SetBinContent(1297,0.8870085);
  hrf->SetBinContent(1298,0.8991774);
  hrf->SetBinContent(1299,0.8926399);
  hrf->SetBinContent(1300,0.8870129);
  hrf->SetBinContent(1301,0.8906647);
  hrf->SetBinContent(1302,0.8820221);
  hrf->SetBinContent(1303,0.8845586);
  hrf->SetBinContent(1304,0.8838417);
  hrf->SetBinContent(1305,0.8976349);
  hrf->SetBinContent(1306,0.8372204);
  hrf->SetBinContent(1307,0.8087633);
  hrf->SetBinContent(1308,0.7906018);
  hrf->SetBinContent(1309,0.7978083);
  hrf->SetBinContent(1310,0.8068362);
  hrf->SetBinContent(1311,0.8253238);
  hrf->SetBinContent(1312,0.8308318);
  hrf->SetBinContent(1313,0.830837);
  hrf->SetBinContent(1314,0.843081);
  hrf->SetBinContent(1315,0.8388117);
  hrf->SetBinContent(1316,0.8409643);
  hrf->SetBinContent(1317,0.8563442);
  hrf->SetBinContent(1318,0.8509172);
  hrf->SetBinContent(1319,0.8564285);
  hrf->SetBinContent(1320,0.8673294);
  hrf->SetBinContent(1321,0.8626825);
  hrf->SetBinContent(1322,0.8700428);
  hrf->SetBinContent(1323,0.8636473);
  hrf->SetBinContent(1324,0.8590862);
  hrf->SetBinContent(1325,0.8522475);
  hrf->SetBinContent(1326,0.8558971);
  hrf->SetBinContent(1327,0.8603112);
  hrf->SetBinContent(1328,0.842573);
  hrf->SetBinContent(1329,0.8557246);
  hrf->SetBinContent(1330,0.8234622);
  hrf->SetBinContent(1331,0.8358622);
  hrf->SetBinContent(1332,0.8263366);
  hrf->SetBinContent(1333,0.8189109);
  hrf->SetBinContent(1334,0.816338);
  hrf->SetBinContent(1335,0.8143541);
  hrf->SetBinContent(1336,0.7975664);
  hrf->SetBinContent(1337,0.7881635);
  hrf->SetBinContent(1338,0.7916959);
  hrf->SetBinContent(1339,0.8189511);
  hrf->SetBinContent(1340,0.8926195);
  hrf->SetBinContent(1341,0.8730372);
  hrf->SetBinContent(1342,0.8798155);
  hrf->SetBinContent(1343,0.8815677);
  hrf->SetBinContent(1344,0.8766184);
  hrf->SetBinContent(1345,0.8825352);
  hrf->SetBinContent(1346,0.8861911);
  hrf->SetBinContent(1347,0.8899728);
  hrf->SetBinContent(1348,0.8807881);
  hrf->SetBinContent(1351,0.8982675);
  hrf->SetBinContent(1352,0.9019269);
  hrf->SetBinContent(1353,0.9040346);
  hrf->SetBinContent(1354,0.9019893);
  hrf->SetBinContent(1355,0.8894359);
  hrf->SetBinContent(1356,0.891537);
  hrf->SetBinContent(1357,0.8923806);
  hrf->SetBinContent(1358,0.9037331);
  hrf->SetBinContent(1359,0.9070863);
  hrf->SetBinContent(1360,0.8309636);
  hrf->SetBinContent(1361,0.8082155);
  hrf->SetBinContent(1362,0.801677);
  hrf->SetBinContent(1363,0.8170729);
  hrf->SetBinContent(1364,0.8248354);
  hrf->SetBinContent(1365,0.8357266);
  hrf->SetBinContent(1366,0.8433401);
  hrf->SetBinContent(1367,0.8358836);
  hrf->SetBinContent(1368,0.8491398);
  hrf->SetBinContent(1369,0.8511904);
  hrf->SetBinContent(1370,0.8482686);
  hrf->SetBinContent(1371,0.8513967);
  hrf->SetBinContent(1372,0.8541074);
  hrf->SetBinContent(1373,0.8674045);
  hrf->SetBinContent(1374,0.8624163);
  hrf->SetBinContent(1375,0.8562872);
  hrf->SetBinContent(1376,0.8609194);
  hrf->SetBinContent(1377,0.8690702);
  hrf->SetBinContent(1378,0.866069);
  hrf->SetBinContent(1379,0.8622828);
  hrf->SetBinContent(1380,0.8604844);
  hrf->SetBinContent(1381,0.8772358);
  hrf->SetBinContent(1382,0.8641567);
  hrf->SetBinContent(1383,0.8457034);
  hrf->SetBinContent(1384,0.8491502);
  hrf->SetBinContent(1385,0.8494045);
  hrf->SetBinContent(1386,0.8261307);
  hrf->SetBinContent(1387,0.8288372);
  hrf->SetBinContent(1388,0.8187173);
  hrf->SetBinContent(1389,0.8281093);
  hrf->SetBinContent(1390,0.8122792);
  hrf->SetBinContent(1391,0.8135304);
  hrf->SetBinContent(1392,0.8265573);
  hrf->SetBinContent(1393,0.8462977);
  hrf->SetBinContent(1394,0.8973685);
  hrf->SetBinContent(1395,0.8940501);
  hrf->SetBinContent(1396,0.8864163);
  hrf->SetBinContent(1397,0.8840707);
  hrf->SetBinContent(1398,0.8922193);
  hrf->SetBinContent(1399,0.8833568);
  hrf->SetBinContent(1400,0.9008134);
  hrf->SetBinContent(1401,0.8976256);
  hrf->SetBinContent(1402,0.8968597);
  hrf->SetBinContent(1405,0.9096515);
  hrf->SetBinContent(1406,0.9079437);
  hrf->SetBinContent(1407,0.9061902);
  hrf->SetBinContent(1408,0.9073185);
  hrf->SetBinContent(1409,0.9017385);
  hrf->SetBinContent(1410,0.8944538);
  hrf->SetBinContent(1411,0.8994409);
  hrf->SetBinContent(1412,0.9050456);
  hrf->SetBinContent(1413,0.9051073);
  hrf->SetBinContent(1414,0.8376052);
  hrf->SetBinContent(1415,0.8213562);
  hrf->SetBinContent(1416,0.8097429);
  hrf->SetBinContent(1417,0.8100043);
  hrf->SetBinContent(1418,0.8337875);
  hrf->SetBinContent(1419,0.8238248);
  hrf->SetBinContent(1420,0.8488808);
  hrf->SetBinContent(1421,0.8444864);
  hrf->SetBinContent(1422,0.8627045);
  hrf->SetBinContent(1423,0.8644162);
  hrf->SetBinContent(1424,0.8556103);
  hrf->SetBinContent(1425,0.860347);
  hrf->SetBinContent(1426,0.8722144);
  hrf->SetBinContent(1427,0.8769311);
  hrf->SetBinContent(1428,0.8707542);
  hrf->SetBinContent(1429,0.8762311);
  hrf->SetBinContent(1430,0.8832279);
  hrf->SetBinContent(1431,0.8578157);
  hrf->SetBinContent(1432,0.8768555);
  hrf->SetBinContent(1433,0.85926);
  hrf->SetBinContent(1434,0.8674991);
  hrf->SetBinContent(1435,0.8800728);
  hrf->SetBinContent(1436,0.8607219);
  hrf->SetBinContent(1437,0.8539656);
  hrf->SetBinContent(1438,0.8611016);
  hrf->SetBinContent(1439,0.8641738);
  hrf->SetBinContent(1440,0.832441);
  hrf->SetBinContent(1441,0.845636);
  hrf->SetBinContent(1442,0.8253812);
  hrf->SetBinContent(1443,0.8277629);
  hrf->SetBinContent(1444,0.8094488);
  hrf->SetBinContent(1445,0.8102607);
  hrf->SetBinContent(1446,0.8374236);
  hrf->SetBinContent(1447,0.846537);
  hrf->SetBinContent(1448,0.9172034);
  hrf->SetBinContent(1449,0.897105);
  hrf->SetBinContent(1450,0.8886965);
  hrf->SetBinContent(1451,0.8842038);
  hrf->SetBinContent(1452,0.8968773);
  hrf->SetBinContent(1453,0.9054415);
  hrf->SetBinContent(1454,0.9000773);
  hrf->SetBinContent(1455,0.9038355);
  hrf->SetBinContent(1456,0.9064714);
  hrf->SetBinContent(1459,0.899802);
  hrf->SetBinContent(1460,0.9145996);
  hrf->SetBinContent(1461,0.905336);
  hrf->SetBinContent(1462,0.9158605);
  hrf->SetBinContent(1463,0.9068455);
  hrf->SetBinContent(1464,0.9052793);
  hrf->SetBinContent(1465,0.8971553);
  hrf->SetBinContent(1466,0.9086646);
  hrf->SetBinContent(1467,0.9164911);
  hrf->SetBinContent(1468,0.8460912);
  hrf->SetBinContent(1469,0.832617);
  hrf->SetBinContent(1470,0.8152063);
  hrf->SetBinContent(1471,0.8263153);
  hrf->SetBinContent(1472,0.8475915);
  hrf->SetBinContent(1473,0.8360038);
  hrf->SetBinContent(1474,0.8411368);
  hrf->SetBinContent(1475,0.8615639);
  hrf->SetBinContent(1476,0.8607904);
  hrf->SetBinContent(1477,0.8632756);
  hrf->SetBinContent(1478,0.8569868);
  hrf->SetBinContent(1479,0.8715767);
  hrf->SetBinContent(1480,0.8791357);
  hrf->SetBinContent(1481,0.8727834);
  hrf->SetBinContent(1482,0.8654918);
  hrf->SetBinContent(1483,0.8727071);
  hrf->SetBinContent(1484,0.8726125);
  hrf->SetBinContent(1485,0.8807337);
  hrf->SetBinContent(1486,0.871381);
  hrf->SetBinContent(1487,0.8743151);
  hrf->SetBinContent(1488,0.8673596);
  hrf->SetBinContent(1489,0.8709635);
  hrf->SetBinContent(1490,0.8562741);
  hrf->SetBinContent(1491,0.8762439);
  hrf->SetBinContent(1492,0.8603385);
  hrf->SetBinContent(1493,0.8584014);
  hrf->SetBinContent(1494,0.852763);
  hrf->SetBinContent(1495,0.8577563);
  hrf->SetBinContent(1496,0.8450456);
  hrf->SetBinContent(1497,0.8433108);
  hrf->SetBinContent(1498,0.8130884);
  hrf->SetBinContent(1499,0.8139271);
  hrf->SetBinContent(1500,0.829942);
  hrf->SetBinContent(1501,0.8460317);
  hrf->SetBinContent(1502,0.9045847);
  hrf->SetBinContent(1503,0.8994192);
  hrf->SetBinContent(1504,0.898507);
  hrf->SetBinContent(1505,0.895317);
  hrf->SetBinContent(1506,0.8913231);
  hrf->SetBinContent(1507,0.9042838);
  hrf->SetBinContent(1508,0.9118587);
  hrf->SetBinContent(1509,0.9111838);
  hrf->SetBinContent(1510,0.8987202);
  hrf->SetBinContent(1513,0.8786432);
  hrf->SetBinContent(1514,0.9071894);
  hrf->SetBinContent(1515,0.9054747);
  hrf->SetBinContent(1516,0.895092);
  hrf->SetBinContent(1517,0.9013143);
  hrf->SetBinContent(1518,0.895817);
  hrf->SetBinContent(1519,0.9064602);
  hrf->SetBinContent(1520,0.9189001);
  hrf->SetBinContent(1521,0.9224745);
  hrf->SetBinContent(1522,0.8556603);
  hrf->SetBinContent(1523,0.8297648);
  hrf->SetBinContent(1524,0.8396801);
  hrf->SetBinContent(1525,0.8185809);
  hrf->SetBinContent(1526,0.8336468);
  hrf->SetBinContent(1527,0.8319675);
  hrf->SetBinContent(1528,0.8543238);
  hrf->SetBinContent(1529,0.8597329);
  hrf->SetBinContent(1530,0.8805091);
  hrf->SetBinContent(1531,0.864668);
  hrf->SetBinContent(1532,0.8604107);
  hrf->SetBinContent(1533,0.8609409);
  hrf->SetBinContent(1534,0.8793934);
  hrf->SetBinContent(1535,0.8839759);
  hrf->SetBinContent(1536,0.8776876);
  hrf->SetBinContent(1537,0.8795961);
  hrf->SetBinContent(1538,0.8815914);
  hrf->SetBinContent(1539,0.8900957);
  hrf->SetBinContent(1540,0.8764424);
  hrf->SetBinContent(1541,0.8734661);
  hrf->SetBinContent(1542,0.8842787);
  hrf->SetBinContent(1543,0.8839705);
  hrf->SetBinContent(1544,0.8786647);
  hrf->SetBinContent(1545,0.8700674);
  hrf->SetBinContent(1546,0.8745763);
  hrf->SetBinContent(1547,0.8782504);
  hrf->SetBinContent(1548,0.8584328);
  hrf->SetBinContent(1549,0.8362831);
  hrf->SetBinContent(1550,0.838657);
  hrf->SetBinContent(1551,0.8478499);
  hrf->SetBinContent(1552,0.8168967);
  hrf->SetBinContent(1553,0.8343195);
  hrf->SetBinContent(1554,0.8338705);
  hrf->SetBinContent(1555,0.8557371);
  hrf->SetBinContent(1556,0.912061);
  hrf->SetBinContent(1557,0.8975816);
  hrf->SetBinContent(1558,0.8948125);
  hrf->SetBinContent(1559,0.8940022);
  hrf->SetBinContent(1560,0.8982707);
  hrf->SetBinContent(1561,0.9042674);
  hrf->SetBinContent(1562,0.9041132);
  hrf->SetBinContent(1563,0.9016004);
  hrf->SetBinContent(1564,0.871017);

  return hrf;

}


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

TH2D* TCMETAlgo::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* TCMETAlgo::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;
}