baby.cpp

Go to the documentation of this file.

#include "baby.hpp"

#include <mutex>
#include <type_traits>
#include <utility>
#include <stdexcept>

#include "named_func.hpp"
#include "utilities.hpp"

using namespace std;

namespace{
  using ScalarType = NamedFunc::ScalarType;
  using VectorType = NamedFunc::VectorType;
  using ScalarFunc = NamedFunc::ScalarFunc;
  using VectorFunc = NamedFunc::VectorFunc;

  template<typename T>
    NamedFunc GetFunction(T,
                          const string &name){
    DBG("Could not find appropriate type for \"" << name << ".\"");
    return NamedFunc(name, [](const Baby &){return 0.;}, false);
  }

  template<typename T>
    NamedFunc GetFunction(T const &(Baby::*baby_func)() const,
                          const string &name){
    return NamedFunc(name,
                     [baby_func](const Baby &b){
                       return ScalarType((b.*baby_func)());
                     });
  }

  template<typename T>
    NamedFunc GetFunction(vector<T>* const &(Baby::*baby_func)() const,
                          const string &name){
    return NamedFunc(name,
                     [baby_func](const Baby &b){
                       const auto &raw = (b.*baby_func)();
                       return VectorType(raw->cbegin(), raw->cend());
                     });
  }

}

Baby::Activator::Activator(Baby &baby):
  baby_(baby){
  baby_.ActivateChain();
}

Baby::Activator::~Activator(){
  baby_.DeactivateChain();
}

Baby::Baby(const set<string> &file_names,
           const set<const Process*> &processes):
  processes_(processes),
  chain_(nullptr),
  file_names_(file_names),
  total_entries_(0),
  cached_total_entries_(false),
  dphi1_{},
  b_dphi1_(nullptr),
  c_dphi1_(false),
  dphi2_{},
  b_dphi2_(nullptr),
  c_dphi2_(false),
  dphi3_{},
  b_dphi3_(nullptr),
  c_dphi3_(false),
  dphi4_{},
  b_dphi4_(nullptr),
  c_dphi4_(false),
  dphi_wlep_{},
  b_dphi_wlep_(nullptr),
  c_dphi_wlep_(false),
  eff_jetid_{},
  b_eff_jetid_(nullptr),
  c_eff_jetid_(false),
  eff_trig_{},
  b_eff_trig_(nullptr),
  c_eff_trig_(false),
  elel_eta_{},
  b_elel_eta_(nullptr),
  c_elel_eta_(false),
  elel_m_{},
  b_elel_m_(nullptr),
  c_elel_m_(false),
  elel_phi_{},
  b_elel_phi_(nullptr),
  c_elel_phi_(false),
  elel_pt_{},
  b_elel_pt_(nullptr),
  c_elel_pt_(false),
  elel_pt1_{},
  b_elel_pt1_(nullptr),
  c_elel_pt1_(false),
  elel_pt2_{},
  b_elel_pt2_(nullptr),
  c_elel_pt2_(false),
  elel_w_{},
  b_elel_w_(nullptr),
  c_elel_w_(false),
  elelv_eta_{},
  b_elelv_eta_(nullptr),
  c_elelv_eta_(false),
  elelv_m_{},
  b_elelv_m_(nullptr),
  c_elelv_m_(false),
  elelv_phi_{},
  b_elelv_phi_(nullptr),
  c_elelv_phi_(false),
  elelv_pt_{},
  b_elelv_pt_(nullptr),
  c_elelv_pt_(false),
  elelv_pt1_{},
  b_elelv_pt1_(nullptr),
  c_elelv_pt1_(false),
  elelv_pt2_{},
  b_elelv_pt2_(nullptr),
  c_elelv_pt2_(false),
  elelv_w_{},
  b_elelv_w_(nullptr),
  c_elelv_w_(false),
  elmu_eta_{},
  b_elmu_eta_(nullptr),
  c_elmu_eta_(false),
  elmu_m_{},
  b_elmu_m_(nullptr),
  c_elmu_m_(false),
  elmu_phi_{},
  b_elmu_phi_(nullptr),
  c_elmu_phi_(false),
  elmu_pt_{},
  b_elmu_pt_(nullptr),
  c_elmu_pt_(false),
  elmu_pt1_{},
  b_elmu_pt1_(nullptr),
  c_elmu_pt1_(false),
  elmu_pt2_{},
  b_elmu_pt2_(nullptr),
  c_elmu_pt2_(false),
  elmu_w_{},
  b_elmu_w_(nullptr),
  c_elmu_w_(false),
  els_charge_{},
  b_els_charge_(nullptr),
  c_els_charge_(false),
  els_d0_{},
  b_els_d0_(nullptr),
  c_els_d0_(false),
  els_deta_sctrk_{},
  b_els_deta_sctrk_(nullptr),
  c_els_deta_sctrk_(false),
  els_dphi_sctrk_{},
  b_els_dphi_sctrk_(nullptr),
  c_els_dphi_sctrk_(false),
  els_dz_{},
  b_els_dz_(nullptr),
  c_els_dz_(false),
  els_ele105_{},
  b_els_ele105_(nullptr),
  c_els_ele105_(false),
  els_ele23_{},
  b_els_ele23_(nullptr),
  c_els_ele23_(false),
  els_ele8_{},
  b_els_ele8_(nullptr),
  c_els_ele8_(false),
  els_em_e_{},
  b_els_em_e_(nullptr),
  c_els_em_e_(false),
  els_eoverp_{},
  b_els_eoverp_(nullptr),
  c_els_eoverp_(false),
  els_eta_{},
  b_els_eta_(nullptr),
  c_els_eta_(false),
  els_hovere_{},
  b_els_hovere_(nullptr),
  c_els_hovere_(false),
  els_inz_{},
  b_els_inz_(nullptr),
  c_els_inz_(false),
  els_inzv_{},
  b_els_inzv_(nullptr),
  c_els_inzv_(false),
  els_ip3d_{},
  b_els_ip3d_(nullptr),
  c_els_ip3d_(false),
  els_ispf_{},
  b_els_ispf_(nullptr),
  c_els_ispf_(false),
  els_miniso_{},
  b_els_miniso_(nullptr),
  c_els_miniso_(false),
  els_phi_{},
  b_els_phi_(nullptr),
  c_els_phi_(false),
  els_pt_{},
  b_els_pt_(nullptr),
  c_els_pt_(false),
  els_reliso_{},
  b_els_reliso_(nullptr),
  c_els_reliso_(false),
  els_sceta_{},
  b_els_sceta_(nullptr),
  c_els_sceta_(false),
  els_sig_{},
  b_els_sig_(nullptr),
  c_els_sig_(false),
  els_sigid_{},
  b_els_sigid_(nullptr),
  c_els_sigid_(false),
  els_tight_{},
  b_els_tight_(nullptr),
  c_els_tight_(false),
  els_tm_{},
  b_els_tm_(nullptr),
  c_els_tm_(false),
  els_trk_nholes_{},
  b_els_trk_nholes_(nullptr),
  c_els_trk_nholes_(false),
  els_trk_pt_{},
  b_els_trk_pt_(nullptr),
  c_els_trk_pt_(false),
  els_trk_pterr_{},
  b_els_trk_pterr_(nullptr),
  c_els_trk_pterr_(false),
  els_vvvl_{},
  b_els_vvvl_(nullptr),
  c_els_vvvl_(false),
  els_vvvl_eta_{},
  b_els_vvvl_eta_(nullptr),
  c_els_vvvl_eta_(false),
  els_vvvl_phi_{},
  b_els_vvvl_phi_(nullptr),
  c_els_vvvl_phi_(false),
  els_vvvl_pt_{},
  b_els_vvvl_pt_(nullptr),
  c_els_vvvl_pt_(false),
  event_{},
  b_event_(nullptr),
  c_event_(false),
  fjets14_eta_{},
  b_fjets14_eta_(nullptr),
  c_fjets14_eta_(false),
  fjets14_m_{},
  b_fjets14_m_(nullptr),
  c_fjets14_m_(false),
  fjets14_nconst_{},
  b_fjets14_nconst_(nullptr),
  c_fjets14_nconst_(false),
  fjets14_phi_{},
  b_fjets14_phi_(nullptr),
  c_fjets14_phi_(false),
  fjets14_pt_{},
  b_fjets14_pt_(nullptr),
  c_fjets14_pt_(false),
  fjets40_eta_{},
  b_fjets40_eta_(nullptr),
  c_fjets40_eta_(false),
  fjets40_m_{},
  b_fjets40_m_(nullptr),
  c_fjets40_m_(false),
  fjets40_nconst_{},
  b_fjets40_nconst_(nullptr),
  c_fjets40_nconst_(false),
  fjets40_phi_{},
  b_fjets40_phi_(nullptr),
  c_fjets40_phi_(false),
  fjets40_pt_{},
  b_fjets40_pt_(nullptr),
  c_fjets40_pt_(false),
  fromGS_{},
  b_fromGS_(nullptr),
  c_fromGS_(false),
  hig1_eta_{},
  b_hig1_eta_(nullptr),
  c_hig1_eta_(false),
  hig1_m_{},
  b_hig1_m_(nullptr),
  c_hig1_m_(false),
  hig1_phi_{},
  b_hig1_phi_(nullptr),
  c_hig1_phi_(false),
  hig1_pt_{},
  b_hig1_pt_(nullptr),
  c_hig1_pt_(false),
  hig2_eta_{},
  b_hig2_eta_(nullptr),
  c_hig2_eta_(false),
  hig2_m_{},
  b_hig2_m_(nullptr),
  c_hig2_m_(false),
  hig2_phi_{},
  b_hig2_phi_(nullptr),
  c_hig2_phi_(false),
  hig2_pt_{},
  b_hig2_pt_(nullptr),
  c_hig2_pt_(false),
  hig_am_{},
  b_hig_am_(nullptr),
  c_hig_am_(false),
  hig_bin_{},
  b_hig_bin_(nullptr),
  c_hig_bin_(false),
  hig_dm_{},
  b_hig_dm_(nullptr),
  c_hig_dm_(false),
  hig_dphi_{},
  b_hig_dphi_(nullptr),
  c_hig_dphi_(false),
  hig_drmax_{},
  b_hig_drmax_(nullptr),
  c_hig_drmax_(false),
  ht_{},
  b_ht_(nullptr),
  c_ht_(false),
  ht40_{},
  b_ht40_(nullptr),
  c_ht40_(false),
  ht50_{},
  b_ht50_(nullptr),
  c_ht50_(false),
  ht_clean_{},
  b_ht_clean_(nullptr),
  c_ht_clean_(false),
  ht_hlt_{},
  b_ht_hlt_(nullptr),
  c_ht_hlt_(false),
  ht_isr_me_{},
  b_ht_isr_me_(nullptr),
  c_ht_isr_me_(false),
  ht_ra2_{},
  b_ht_ra2_(nullptr),
  c_ht_ra2_(false),
  ht_tru_{},
  b_ht_tru_(nullptr),
  c_ht_tru_(false),
  htx_{},
  b_htx_(nullptr),
  c_htx_(false),
  htx40_{},
  b_htx40_(nullptr),
  c_htx40_(false),
  htx50_{},
  b_htx50_(nullptr),
  c_htx50_(false),
  isr_tru_eta_{},
  b_isr_tru_eta_(nullptr),
  c_isr_tru_eta_(false),
  isr_tru_phi_{},
  b_isr_tru_phi_(nullptr),
  c_isr_tru_phi_(false),
  isr_tru_pt_{},
  b_isr_tru_pt_(nullptr),
  c_isr_tru_pt_(false),
  jetmismeas_{},
  b_jetmismeas_(nullptr),
  c_jetmismeas_(false),
  jets_csv_{},
  b_jets_csv_(nullptr),
  c_jets_csv_(false),
  jets_eta_{},
  b_jets_eta_(nullptr),
  c_jets_eta_(false),
  jets_fjet08_index_{},
  b_jets_fjet08_index_(nullptr),
  c_jets_fjet08_index_(false),
  jets_fjet12_index_{},
  b_jets_fjet12_index_(nullptr),
  c_jets_fjet12_index_(false),
  jets_fjet14_index_{},
  b_jets_fjet14_index_(nullptr),
  c_jets_fjet14_index_(false),
  jets_fjet14_nolep_index_{},
  b_jets_fjet14_nolep_index_(nullptr),
  c_jets_fjet14_nolep_index_(false),
  jets_fjet40_index_{},
  b_jets_fjet40_index_(nullptr),
  c_jets_fjet40_index_(false),
  jets_fjet50_index_{},
  b_jets_fjet50_index_(nullptr),
  c_jets_fjet50_index_(false),
  jets_h1_{},
  b_jets_h1_(nullptr),
  c_jets_h1_(false),
  jets_h2_{},
  b_jets_h2_(nullptr),
  c_jets_h2_(false),
  jets_hflavor_{},
  b_jets_hflavor_(nullptr),
  c_jets_hflavor_(false),
  jets_isisr_{},
  b_jets_isisr_(nullptr),
  c_jets_isisr_(false),
  jets_islep_{},
  b_jets_islep_(nullptr),
  c_jets_islep_(false),
  jets_m_{},
  b_jets_m_(nullptr),
  c_jets_m_(false),
  jets_phi_{},
  b_jets_phi_(nullptr),
  c_jets_phi_(false),
  jets_pt_{},
  b_jets_pt_(nullptr),
  c_jets_pt_(false),
  jets_pt_res_{},
  b_jets_pt_res_(nullptr),
  c_jets_pt_res_(false),
  jetsys_eta_{},
  b_jetsys_eta_(nullptr),
  c_jetsys_eta_(false),
  jetsys_m_{},
  b_jetsys_m_(nullptr),
  c_jetsys_m_(false),
  jetsys_nob_eta_{},
  b_jetsys_nob_eta_(nullptr),
  c_jetsys_nob_eta_(false),
  jetsys_nob_m_{},
  b_jetsys_nob_m_(nullptr),
  c_jetsys_nob_m_(false),
  jetsys_nob_phi_{},
  b_jetsys_nob_phi_(nullptr),
  c_jetsys_nob_phi_(false),
  jetsys_nob_pt_{},
  b_jetsys_nob_pt_(nullptr),
  c_jetsys_nob_pt_(false),
  jetsys_phi_{},
  b_jetsys_phi_(nullptr),
  c_jetsys_phi_(false),
  jetsys_pt_{},
  b_jetsys_pt_(nullptr),
  c_jetsys_pt_(false),
  json12p9_{},
  b_json12p9_(nullptr),
  c_json12p9_(false),
  json2p6_{},
  b_json2p6_(nullptr),
  c_json2p6_(false),
  json4p0_{},
  b_json4p0_(nullptr),
  c_json4p0_(false),
  json7p65_{},
  b_json7p65_(nullptr),
  c_json7p65_(false),
  leps_eta_{},
  b_leps_eta_(nullptr),
  c_leps_eta_(false),
  leps_id_{},
  b_leps_id_(nullptr),
  c_leps_id_(false),
  leps_phi_{},
  b_leps_phi_(nullptr),
  c_leps_phi_(false),
  leps_pt_{},
  b_leps_pt_(nullptr),
  c_leps_pt_(false),
  low_dphi_{},
  b_low_dphi_(nullptr),
  c_low_dphi_(false),
  lumiblock_{},
  b_lumiblock_(nullptr),
  c_lumiblock_(false),
  m_tt_{},
  b_m_tt_(nullptr),
  c_m_tt_(false),
  mc_eta_{},
  b_mc_eta_(nullptr),
  c_mc_eta_(false),
  mc_id_{},
  b_mc_id_(nullptr),
  c_mc_id_(false),
  mc_mass_{},
  b_mc_mass_(nullptr),
  c_mc_mass_(false),
  mc_mom_{},
  b_mc_mom_(nullptr),
  c_mc_mom_(false),
  mc_momidx_{},
  b_mc_momidx_(nullptr),
  c_mc_momidx_(false),
  mc_phi_{},
  b_mc_phi_(nullptr),
  c_mc_phi_(false),
  mc_pt_{},
  b_mc_pt_(nullptr),
  c_mc_pt_(false),
  mc_status_{},
  b_mc_status_(nullptr),
  c_mc_status_(false),
  mct_{},
  b_mct_(nullptr),
  c_mct_(false),
  met_{},
  b_met_(nullptr),
  c_met_(false),
  met_calo_{},
  b_met_calo_(nullptr),
  c_met_calo_(false),
  met_calo_phi_{},
  b_met_calo_phi_(nullptr),
  c_met_calo_phi_(false),
  met_mini_{},
  b_met_mini_(nullptr),
  c_met_mini_(false),
  met_mini_phi_{},
  b_met_mini_phi_(nullptr),
  c_met_mini_phi_(false),
  met_nohf_{},
  b_met_nohf_(nullptr),
  c_met_nohf_(false),
  met_nohf_phi_{},
  b_met_nohf_phi_(nullptr),
  c_met_nohf_phi_(false),
  met_phi_{},
  b_met_phi_(nullptr),
  c_met_phi_(false),
  met_raw_{},
  b_met_raw_(nullptr),
  c_met_raw_(false),
  met_raw_phi_{},
  b_met_raw_phi_(nullptr),
  c_met_raw_phi_(false),
  met_rebal_{},
  b_met_rebal_(nullptr),
  c_met_rebal_(false),
  met_tru_{},
  b_met_tru_(nullptr),
  c_met_tru_(false),
  met_tru_nuw_{},
  b_met_tru_nuw_(nullptr),
  c_met_tru_nuw_(false),
  met_tru_nuw_phi_{},
  b_met_tru_nuw_phi_(nullptr),
  c_met_tru_nuw_phi_(false),
  met_tru_phi_{},
  b_met_tru_phi_(nullptr),
  c_met_tru_phi_(false),
  mgluino_{},
  b_mgluino_(nullptr),
  c_mgluino_(false),
  mht_{},
  b_mht_(nullptr),
  c_mht_(false),
  mht_clean_{},
  b_mht_clean_(nullptr),
  c_mht_clean_(false),
  mht_clean_phi_{},
  b_mht_clean_phi_(nullptr),
  c_mht_clean_phi_(false),
  mht_phi_{},
  b_mht_phi_(nullptr),
  c_mht_phi_(false),
  mj08_{},
  b_mj08_(nullptr),
  c_mj08_(false),
  mj12_{},
  b_mj12_(nullptr),
  c_mj12_(false),
  mj14_{},
  b_mj14_(nullptr),
  c_mj14_(false),
  mj14_nolep_{},
  b_mj14_nolep_(nullptr),
  c_mj14_nolep_(false),
  mj40_{},
  b_mj40_(nullptr),
  c_mj40_(false),
  mj50_{},
  b_mj50_(nullptr),
  c_mj50_(false),
  mlsp_{},
  b_mlsp_(nullptr),
  c_mlsp_(false),
  mm_{},
  b_mm_(nullptr),
  c_mm_(false),
  mm_el_miniso_{},
  b_mm_el_miniso_(nullptr),
  c_mm_el_miniso_(false),
  mm_el_pt_{},
  b_mm_el_pt_(nullptr),
  c_mm_el_pt_(false),
  mm_ht_{},
  b_mm_ht_(nullptr),
  c_mm_ht_(false),
  mm_jet_eta_{},
  b_mm_jet_eta_(nullptr),
  c_mm_jet_eta_(false),
  mm_jet_m_{},
  b_mm_jet_m_(nullptr),
  c_mm_jet_m_(false),
  mm_jet_phi_{},
  b_mm_jet_phi_(nullptr),
  c_mm_jet_phi_(false),
  mm_jet_pt_{},
  b_mm_jet_pt_(nullptr),
  c_mm_jet_pt_(false),
  mm_lep_pt_{},
  b_mm_lep_pt_(nullptr),
  c_mm_lep_pt_(false),
  mm_met_{},
  b_mm_met_(nullptr),
  c_mm_met_(false),
  mm_met_phi_{},
  b_mm_met_phi_(nullptr),
  c_mm_met_phi_(false),
  mm_mj14_lep_{},
  b_mm_mj14_lep_(nullptr),
  c_mm_mj14_lep_(false),
  mm_mj14_nolep_{},
  b_mm_mj14_nolep_(nullptr),
  c_mm_mj14_nolep_(false),
  mm_mt_{},
  b_mm_mt_(nullptr),
  c_mm_mt_(false),
  mm_mu_miniso_{},
  b_mm_mu_miniso_(nullptr),
  c_mm_mu_miniso_(false),
  mm_mu_pt_{},
  b_mm_mu_pt_(nullptr),
  c_mm_mu_pt_(false),
  mm_nbm_{},
  b_mm_nbm_(nullptr),
  c_mm_nbm_(false),
  mm_nels_{},
  b_mm_nels_(nullptr),
  c_mm_nels_(false),
  mm_njets_{},
  b_mm_njets_(nullptr),
  c_mm_njets_(false),
  mm_nleps_{},
  b_mm_nleps_(nullptr),
  c_mm_nleps_(false),
  mm_nmus_{},
  b_mm_nmus_(nullptr),
  c_mm_nmus_(false),
  mt_{},
  b_mt_(nullptr),
  c_mt_(false),
  mt2_{},
  b_mt2_(nullptr),
  c_mt2_(false),
  mt2_0mass_{},
  b_mt2_0mass_(nullptr),
  c_mt2_0mass_(false),
  mt_nohf_{},
  b_mt_nohf_(nullptr),
  c_mt_nohf_(false),
  mt_rebal_{},
  b_mt_rebal_(nullptr),
  c_mt_rebal_(false),
  mt_tru_{},
  b_mt_tru_(nullptr),
  c_mt_tru_(false),
  mt_tru_nuw_{},
  b_mt_tru_nuw_(nullptr),
  c_mt_tru_nuw_(false),
  mumu_eta_{},
  b_mumu_eta_(nullptr),
  c_mumu_eta_(false),
  mumu_m_{},
  b_mumu_m_(nullptr),
  c_mumu_m_(false),
  mumu_phi_{},
  b_mumu_phi_(nullptr),
  c_mumu_phi_(false),
  mumu_pt_{},
  b_mumu_pt_(nullptr),
  c_mumu_pt_(false),
  mumu_pt1_{},
  b_mumu_pt1_(nullptr),
  c_mumu_pt1_(false),
  mumu_pt2_{},
  b_mumu_pt2_(nullptr),
  c_mumu_pt2_(false),
  mumu_w_{},
  b_mumu_w_(nullptr),
  c_mumu_w_(false),
  mumuv_eta_{},
  b_mumuv_eta_(nullptr),
  c_mumuv_eta_(false),
  mumuv_m_{},
  b_mumuv_m_(nullptr),
  c_mumuv_m_(false),
  mumuv_phi_{},
  b_mumuv_phi_(nullptr),
  c_mumuv_phi_(false),
  mumuv_pt_{},
  b_mumuv_pt_(nullptr),
  c_mumuv_pt_(false),
  mumuv_pt1_{},
  b_mumuv_pt1_(nullptr),
  c_mumuv_pt1_(false),
  mumuv_pt2_{},
  b_mumuv_pt2_(nullptr),
  c_mumuv_pt2_(false),
  mumuv_w_{},
  b_mumuv_w_(nullptr),
  c_mumuv_w_(false),
  mus_charge_{},
  b_mus_charge_(nullptr),
  c_mus_charge_(false),
  mus_d0_{},
  b_mus_d0_(nullptr),
  c_mus_d0_(false),
  mus_dz_{},
  b_mus_dz_(nullptr),
  c_mus_dz_(false),
  mus_em_e_{},
  b_mus_em_e_(nullptr),
  c_mus_em_e_(false),
  mus_eta_{},
  b_mus_eta_(nullptr),
  c_mus_eta_(false),
  mus_had_e_{},
  b_mus_had_e_(nullptr),
  c_mus_had_e_(false),
  mus_inz_{},
  b_mus_inz_(nullptr),
  c_mus_inz_(false),
  mus_inzv_{},
  b_mus_inzv_(nullptr),
  c_mus_inzv_(false),
  mus_isomu18_{},
  b_mus_isomu18_(nullptr),
  c_mus_isomu18_(false),
  mus_miniso_{},
  b_mus_miniso_(nullptr),
  c_mus_miniso_(false),
  mus_mu50_{},
  b_mus_mu50_(nullptr),
  c_mus_mu50_(false),
  mus_mu8_{},
  b_mus_mu8_(nullptr),
  c_mus_mu8_(false),
  mus_phi_{},
  b_mus_phi_(nullptr),
  c_mus_phi_(false),
  mus_pt_{},
  b_mus_pt_(nullptr),
  c_mus_pt_(false),
  mus_pterr_{},
  b_mus_pterr_(nullptr),
  c_mus_pterr_(false),
  mus_reliso_{},
  b_mus_reliso_(nullptr),
  c_mus_reliso_(false),
  mus_sig_{},
  b_mus_sig_(nullptr),
  c_mus_sig_(false),
  mus_sigid_{},
  b_mus_sigid_(nullptr),
  c_mus_sigid_(false),
  mus_tight_{},
  b_mus_tight_(nullptr),
  c_mus_tight_(false),
  mus_tm_{},
  b_mus_tm_(nullptr),
  c_mus_tm_(false),
  mus_trk_algo_{},
  b_mus_trk_algo_(nullptr),
  c_mus_trk_algo_(false),
  mus_trk_nholes_in_{},
  b_mus_trk_nholes_in_(nullptr),
  c_mus_trk_nholes_in_(false),
  mus_trk_nholes_out_{},
  b_mus_trk_nholes_out_(nullptr),
  c_mus_trk_nholes_out_(false),
  mus_trk_quality_{},
  b_mus_trk_quality_(nullptr),
  c_mus_trk_quality_(false),
  mus_vvvl_{},
  b_mus_vvvl_(nullptr),
  c_mus_vvvl_(false),
  mus_vvvl_eta_{},
  b_mus_vvvl_eta_(nullptr),
  c_mus_vvvl_eta_(false),
  mus_vvvl_phi_{},
  b_mus_vvvl_phi_(nullptr),
  c_mus_vvvl_phi_(false),
  mus_vvvl_pt_{},
  b_mus_vvvl_pt_(nullptr),
  c_mus_vvvl_pt_(false),
  nbl_{},
  b_nbl_(nullptr),
  c_nbl_(false),
  nbm_{},
  b_nbm_(nullptr),
  c_nbm_(false),
  nbm20_{},
  b_nbm20_(nullptr),
  c_nbm20_(false),
  nbm40_{},
  b_nbm40_(nullptr),
  c_nbm40_(false),
  nbm50_{},
  b_nbm50_(nullptr),
  c_nbm50_(false),
  nbm_ra2_{},
  b_nbm_ra2_(nullptr),
  c_nbm_ra2_(false),
  nbt_{},
  b_nbt_(nullptr),
  c_nbt_(false),
  nels_{},
  b_nels_(nullptr),
  c_nels_(false),
  nels_ele23_{},
  b_nels_ele23_(nullptr),
  c_nels_ele23_(false),
  nels_vvvl_{},
  b_nels_vvvl_(nullptr),
  c_nels_vvvl_(false),
  nfjets14_{},
  b_nfjets14_(nullptr),
  c_nfjets14_(false),
  nfjets40_{},
  b_nfjets40_(nullptr),
  c_nfjets40_(false),
  nisr_{},
  b_nisr_(nullptr),
  c_nisr_(false),
  nisr_me_{},
  b_nisr_me_(nullptr),
  c_nisr_me_(false),
  njets_{},
  b_njets_(nullptr),
  c_njets_(false),
  njets20_{},
  b_njets20_(nullptr),
  c_njets20_(false),
  njets40_{},
  b_njets40_(nullptr),
  c_njets40_(false),
  njets50_{},
  b_njets50_(nullptr),
  c_njets50_(false),
  njets_clean_{},
  b_njets_clean_(nullptr),
  c_njets_clean_(false),
  njets_ra2_{},
  b_njets_ra2_(nullptr),
  c_njets_ra2_(false),
  nleps_{},
  b_nleps_(nullptr),
  c_nleps_(false),
  nleps_tm_{},
  b_nleps_tm_(nullptr),
  c_nleps_tm_(false),
  nmus_{},
  b_nmus_(nullptr),
  c_nmus_(false),
  nmus_isomu18_{},
  b_nmus_isomu18_(nullptr),
  c_nmus_isomu18_(false),
  nmus_vvvl_{},
  b_nmus_vvvl_(nullptr),
  c_nmus_vvvl_(false),
  nonblind_{},
  b_nonblind_(nullptr),
  c_nonblind_(false),
  nph_{},
  b_nph_(nullptr),
  c_nph_(false),
  npv_{},
  b_npv_(nullptr),
  c_npv_(false),
  ntks_{},
  b_ntks_(nullptr),
  c_ntks_(false),
  ntruels_{},
  b_ntruels_(nullptr),
  c_ntruels_(false),
  ntruleps_{},
  b_ntruleps_(nullptr),
  c_ntruleps_(false),
  ntrumus_{},
  b_ntrumus_(nullptr),
  c_ntrumus_(false),
  ntrupv_{},
  b_ntrupv_(nullptr),
  c_ntrupv_(false),
  ntrupv_mean_{},
  b_ntrupv_mean_(nullptr),
  c_ntrupv_mean_(false),
  ntrutaush_{},
  b_ntrutaush_(nullptr),
  c_ntrutaush_(false),
  ntrutausl_{},
  b_ntrutausl_(nullptr),
  c_ntrutausl_(false),
  nvels_{},
  b_nvels_(nullptr),
  c_nvels_(false),
  nveto_{},
  b_nveto_(nullptr),
  c_nveto_(false),
  nvleps_{},
  b_nvleps_(nullptr),
  c_nvleps_(false),
  nvmus_{},
  b_nvmus_(nullptr),
  c_nvmus_(false),
  onel_ele105_{},
  b_onel_ele105_(nullptr),
  c_onel_ele105_(false),
  onel_ele23_{},
  b_onel_ele23_(nullptr),
  c_onel_ele23_(false),
  onel_ele8_{},
  b_onel_ele8_(nullptr),
  c_onel_ele8_(false),
  onel_vvvl_{},
  b_onel_vvvl_(nullptr),
  c_onel_vvvl_(false),
  onht_{},
  b_onht_(nullptr),
  c_onht_(false),
  onmet_{},
  b_onmet_(nullptr),
  c_onmet_(false),
  onmu_isomu18_{},
  b_onmu_isomu18_(nullptr),
  c_onmu_isomu18_(false),
  onmu_mu50_{},
  b_onmu_mu50_(nullptr),
  c_onmu_mu50_(false),
  onmu_mu8_{},
  b_onmu_mu8_(nullptr),
  c_onmu_mu8_(false),
  onmu_vvvl_{},
  b_onmu_vvvl_(nullptr),
  c_onmu_vvvl_(false),
  onph_ph90_{},
  b_onph_ph90_(nullptr),
  c_onph_ph90_(false),
  pass_{},
  b_pass_(nullptr),
  c_pass_(false),
  pass20_{},
  b_pass20_(nullptr),
  c_pass20_(false),
  pass40_{},
  b_pass40_(nullptr),
  c_pass40_(false),
  pass50_{},
  b_pass50_(nullptr),
  c_pass50_(false),
  pass_cschalo_{},
  b_pass_cschalo_(nullptr),
  c_pass_cschalo_(false),
  pass_ecaldeadcell_{},
  b_pass_ecaldeadcell_(nullptr),
  c_pass_ecaldeadcell_(false),
  pass_eebadsc_{},
  b_pass_eebadsc_(nullptr),
  c_pass_eebadsc_(false),
  pass_goodv_{},
  b_pass_goodv_(nullptr),
  c_pass_goodv_(false),
  pass_hbhe_{},
  b_pass_hbhe_(nullptr),
  c_pass_hbhe_(false),
  pass_hbheiso_{},
  b_pass_hbheiso_(nullptr),
  c_pass_hbheiso_(false),
  pass_jets_{},
  b_pass_jets_(nullptr),
  c_pass_jets_(false),
  pass_jets20_{},
  b_pass_jets20_(nullptr),
  c_pass_jets20_(false),
  pass_jets40_{},
  b_pass_jets40_(nullptr),
  c_pass_jets40_(false),
  pass_jets50_{},
  b_pass_jets50_(nullptr),
  c_pass_jets50_(false),
  pass_jets_nohf_{},
  b_pass_jets_nohf_(nullptr),
  c_pass_jets_nohf_(false),
  pass_jets_ra2_{},
  b_pass_jets_ra2_(nullptr),
  c_pass_jets_ra2_(false),
  pass_jets_tight_{},
  b_pass_jets_tight_(nullptr),
  c_pass_jets_tight_(false),
  pass_jets_tight_ra2_{},
  b_pass_jets_tight_ra2_(nullptr),
  c_pass_jets_tight_ra2_(false),
  pass_nohf_{},
  b_pass_nohf_(nullptr),
  c_pass_nohf_(false),
  pass_ra2_{},
  b_pass_ra2_(nullptr),
  c_pass_ra2_(false),
  pass_ra2_badmu_{},
  b_pass_ra2_badmu_(nullptr),
  c_pass_ra2_badmu_(false),
  ph_eta_{},
  b_ph_eta_(nullptr),
  c_ph_eta_(false),
  ph_ph90_{},
  b_ph_ph90_(nullptr),
  c_ph_ph90_(false),
  ph_phi_{},
  b_ph_phi_(nullptr),
  c_ph_phi_(false),
  ph_pt_{},
  b_ph_pt_(nullptr),
  c_ph_pt_(false),
  ph_tm_{},
  b_ph_tm_(nullptr),
  c_ph_tm_(false),
  run_{},
  b_run_(nullptr),
  c_run_(false),
  st_{},
  b_st_(nullptr),
  c_st_(false),
  st40_{},
  b_st40_(nullptr),
  c_st40_(false),
  st50_{},
  b_st50_(nullptr),
  c_st50_(false),
  stitch_{},
  b_stitch_(nullptr),
  c_stitch_(false),
  sys_bctag_{},
  b_sys_bctag_(nullptr),
  c_sys_bctag_(false),
  sys_bctag40_{},
  b_sys_bctag40_(nullptr),
  c_sys_bctag40_(false),
  sys_bctag_loose_{},
  b_sys_bctag_loose_(nullptr),
  c_sys_bctag_loose_(false),
  sys_fs_bctag_{},
  b_sys_fs_bctag_(nullptr),
  c_sys_fs_bctag_(false),
  sys_fs_bctag40_{},
  b_sys_fs_bctag40_(nullptr),
  c_sys_fs_bctag40_(false),
  sys_fs_lep_{},
  b_sys_fs_lep_(nullptr),
  c_sys_fs_lep_(false),
  sys_fs_udsgtag_{},
  b_sys_fs_udsgtag_(nullptr),
  c_sys_fs_udsgtag_(false),
  sys_fs_udsgtag40_{},
  b_sys_fs_udsgtag40_(nullptr),
  c_sys_fs_udsgtag40_(false),
  sys_ht_{},
  b_sys_ht_(nullptr),
  c_sys_ht_(false),
  sys_ht40_{},
  b_sys_ht40_(nullptr),
  c_sys_ht40_(false),
  sys_isr_{},
  b_sys_isr_(nullptr),
  c_sys_isr_(false),
  sys_lep_{},
  b_sys_lep_(nullptr),
  c_sys_lep_(false),
  sys_met_{},
  b_sys_met_(nullptr),
  c_sys_met_(false),
  sys_mj14_{},
  b_sys_mj14_(nullptr),
  c_sys_mj14_(false),
  sys_mj14_nolep_{},
  b_sys_mj14_nolep_(nullptr),
  c_sys_mj14_nolep_(false),
  sys_mj40_{},
  b_sys_mj40_(nullptr),
  c_sys_mj40_(false),
  sys_mt_{},
  b_sys_mt_(nullptr),
  c_sys_mt_(false),
  sys_muf_{},
  b_sys_muf_(nullptr),
  c_sys_muf_(false),
  sys_mur_{},
  b_sys_mur_(nullptr),
  c_sys_mur_(false),
  sys_murf_{},
  b_sys_murf_(nullptr),
  c_sys_murf_(false),
  sys_nbm_{},
  b_sys_nbm_(nullptr),
  c_sys_nbm_(false),
  sys_nbm40_{},
  b_sys_nbm40_(nullptr),
  c_sys_nbm40_(false),
  sys_njets_{},
  b_sys_njets_(nullptr),
  c_sys_njets_(false),
  sys_njets40_{},
  b_sys_njets40_(nullptr),
  c_sys_njets40_(false),
  sys_pass_{},
  b_sys_pass_(nullptr),
  c_sys_pass_(false),
  sys_pass40_{},
  b_sys_pass40_(nullptr),
  c_sys_pass40_(false),
  sys_pu_{},
  b_sys_pu_(nullptr),
  c_sys_pu_(false),
  sys_st_{},
  b_sys_st_(nullptr),
  c_sys_st_(false),
  sys_st40_{},
  b_sys_st40_(nullptr),
  c_sys_st40_(false),
  sys_trig_{},
  b_sys_trig_(nullptr),
  c_sys_trig_(false),
  sys_udsgtag_{},
  b_sys_udsgtag_(nullptr),
  c_sys_udsgtag_(false),
  sys_udsgtag40_{},
  b_sys_udsgtag40_(nullptr),
  c_sys_udsgtag40_(false),
  sys_udsgtag_loose_{},
  b_sys_udsgtag_loose_(nullptr),
  c_sys_udsgtag_loose_(false),
  tks_d0_{},
  b_tks_d0_(nullptr),
  c_tks_d0_(false),
  tks_dz_{},
  b_tks_dz_(nullptr),
  c_tks_dz_(false),
  tks_eta_{},
  b_tks_eta_(nullptr),
  c_tks_eta_(false),
  tks_miniso_{},
  b_tks_miniso_(nullptr),
  c_tks_miniso_(false),
  tks_mt_{},
  b_tks_mt_(nullptr),
  c_tks_mt_(false),
  tks_mt2_{},
  b_tks_mt2_(nullptr),
  c_tks_mt2_(false),
  tks_pdg_{},
  b_tks_pdg_(nullptr),
  c_tks_pdg_(false),
  tks_phi_{},
  b_tks_phi_(nullptr),
  c_tks_phi_(false),
  tks_pt_{},
  b_tks_pt_(nullptr),
  c_tks_pt_(false),
  tks_reliso_{},
  b_tks_reliso_(nullptr),
  c_tks_reliso_(false),
  tks_tm_{},
  b_tks_tm_(nullptr),
  c_tks_tm_(false),
  trig_{},
  b_trig_(nullptr),
  c_trig_(false),
  trig_lep_{},
  b_trig_lep_(nullptr),
  c_trig_lep_(false),
  trig_met_{},
  b_trig_met_(nullptr),
  c_trig_met_(false),
  trig_prescale_{},
  b_trig_prescale_(nullptr),
  c_trig_prescale_(false),
  trig_ra4_{},
  b_trig_ra4_(nullptr),
  c_trig_ra4_(false),
  trig_vvvl_{},
  b_trig_vvvl_(nullptr),
  c_trig_vvvl_(false),
  type_{},
  b_type_(nullptr),
  c_type_(false),
  w_btag_{},
  b_w_btag_(nullptr),
  c_w_btag_(false),
  w_btag40_{},
  b_w_btag40_(nullptr),
  c_w_btag40_(false),
  w_btag_loose_{},
  b_w_btag_loose_(nullptr),
  c_w_btag_loose_(false),
  w_fs_lep_{},
  b_w_fs_lep_(nullptr),
  c_w_fs_lep_(false),
  w_isr_{},
  b_w_isr_(nullptr),
  c_w_isr_(false),
  w_lep_{},
  b_w_lep_(nullptr),
  c_w_lep_(false),
  w_lumi_{},
  b_w_lumi_(nullptr),
  c_w_lumi_(false),
  w_pu_{},
  b_w_pu_(nullptr),
  c_w_pu_(false),
  w_toppt_{},
  b_w_toppt_(nullptr),
  c_w_toppt_(false),
  weight_{},
  b_weight_(nullptr),
  c_weight_(false),
  weight_rpv_{},
  b_weight_rpv_(nullptr),
  c_weight_rpv_(false){
  TString filename="";
  if(file_names_.size()) filename = *file_names_.cbegin();
  sample_type_ = SetSampleType(filename);
}
long Baby::GetEntries() const{
  if(!cached_total_entries_){
    cached_total_entries_ = true;
    lock_guard<mutex> lock(Multithreading::root_mutex);
    total_entries_ = chain_->GetEntries();
  }
  return total_entries_;
}

void Baby::GetEntry(long entry){
  c_dphi1_ = false;
  c_dphi2_ = false;
  c_dphi3_ = false;
  c_dphi4_ = false;
  c_dphi_wlep_ = false;
  c_eff_jetid_ = false;
  c_eff_trig_ = false;
  c_elel_eta_ = false;
  c_elel_m_ = false;
  c_elel_phi_ = false;
  c_elel_pt_ = false;
  c_elel_pt1_ = false;
  c_elel_pt2_ = false;
  c_elel_w_ = false;
  c_elelv_eta_ = false;
  c_elelv_m_ = false;
  c_elelv_phi_ = false;
  c_elelv_pt_ = false;
  c_elelv_pt1_ = false;
  c_elelv_pt2_ = false;
  c_elelv_w_ = false;
  c_elmu_eta_ = false;
  c_elmu_m_ = false;
  c_elmu_phi_ = false;
  c_elmu_pt_ = false;
  c_elmu_pt1_ = false;
  c_elmu_pt2_ = false;
  c_elmu_w_ = false;
  c_els_charge_ = false;
  c_els_d0_ = false;
  c_els_deta_sctrk_ = false;
  c_els_dphi_sctrk_ = false;
  c_els_dz_ = false;
  c_els_ele105_ = false;
  c_els_ele23_ = false;
  c_els_ele8_ = false;
  c_els_em_e_ = false;
  c_els_eoverp_ = false;
  c_els_eta_ = false;
  c_els_hovere_ = false;
  c_els_inz_ = false;
  c_els_inzv_ = false;
  c_els_ip3d_ = false;
  c_els_ispf_ = false;
  c_els_miniso_ = false;
  c_els_phi_ = false;
  c_els_pt_ = false;
  c_els_reliso_ = false;
  c_els_sceta_ = false;
  c_els_sig_ = false;
  c_els_sigid_ = false;
  c_els_tight_ = false;
  c_els_tm_ = false;
  c_els_trk_nholes_ = false;
  c_els_trk_pt_ = false;
  c_els_trk_pterr_ = false;
  c_els_vvvl_ = false;
  c_els_vvvl_eta_ = false;
  c_els_vvvl_phi_ = false;
  c_els_vvvl_pt_ = false;
  c_event_ = false;
  c_fjets14_eta_ = false;
  c_fjets14_m_ = false;
  c_fjets14_nconst_ = false;
  c_fjets14_phi_ = false;
  c_fjets14_pt_ = false;
  c_fjets40_eta_ = false;
  c_fjets40_m_ = false;
  c_fjets40_nconst_ = false;
  c_fjets40_phi_ = false;
  c_fjets40_pt_ = false;
  c_fromGS_ = false;
  c_hig1_eta_ = false;
  c_hig1_m_ = false;
  c_hig1_phi_ = false;
  c_hig1_pt_ = false;
  c_hig2_eta_ = false;
  c_hig2_m_ = false;
  c_hig2_phi_ = false;
  c_hig2_pt_ = false;
  c_hig_am_ = false;
  c_hig_bin_ = false;
  c_hig_dm_ = false;
  c_hig_dphi_ = false;
  c_hig_drmax_ = false;
  c_ht_ = false;
  c_ht40_ = false;
  c_ht50_ = false;
  c_ht_clean_ = false;
  c_ht_hlt_ = false;
  c_ht_isr_me_ = false;
  c_ht_ra2_ = false;
  c_ht_tru_ = false;
  c_htx_ = false;
  c_htx40_ = false;
  c_htx50_ = false;
  c_isr_tru_eta_ = false;
  c_isr_tru_phi_ = false;
  c_isr_tru_pt_ = false;
  c_jetmismeas_ = false;
  c_jets_csv_ = false;
  c_jets_eta_ = false;
  c_jets_fjet08_index_ = false;
  c_jets_fjet12_index_ = false;
  c_jets_fjet14_index_ = false;
  c_jets_fjet14_nolep_index_ = false;
  c_jets_fjet40_index_ = false;
  c_jets_fjet50_index_ = false;
  c_jets_h1_ = false;
  c_jets_h2_ = false;
  c_jets_hflavor_ = false;
  c_jets_isisr_ = false;
  c_jets_islep_ = false;
  c_jets_m_ = false;
  c_jets_phi_ = false;
  c_jets_pt_ = false;
  c_jets_pt_res_ = false;
  c_jetsys_eta_ = false;
  c_jetsys_m_ = false;
  c_jetsys_nob_eta_ = false;
  c_jetsys_nob_m_ = false;
  c_jetsys_nob_phi_ = false;
  c_jetsys_nob_pt_ = false;
  c_jetsys_phi_ = false;
  c_jetsys_pt_ = false;
  c_json12p9_ = false;
  c_json2p6_ = false;
  c_json4p0_ = false;
  c_json7p65_ = false;
  c_leps_eta_ = false;
  c_leps_id_ = false;
  c_leps_phi_ = false;
  c_leps_pt_ = false;
  c_low_dphi_ = false;
  c_lumiblock_ = false;
  c_m_tt_ = false;
  c_mc_eta_ = false;
  c_mc_id_ = false;
  c_mc_mass_ = false;
  c_mc_mom_ = false;
  c_mc_momidx_ = false;
  c_mc_phi_ = false;
  c_mc_pt_ = false;
  c_mc_status_ = false;
  c_mct_ = false;
  c_met_ = false;
  c_met_calo_ = false;
  c_met_calo_phi_ = false;
  c_met_mini_ = false;
  c_met_mini_phi_ = false;
  c_met_nohf_ = false;
  c_met_nohf_phi_ = false;
  c_met_phi_ = false;
  c_met_raw_ = false;
  c_met_raw_phi_ = false;
  c_met_rebal_ = false;
  c_met_tru_ = false;
  c_met_tru_nuw_ = false;
  c_met_tru_nuw_phi_ = false;
  c_met_tru_phi_ = false;
  c_mgluino_ = false;
  c_mht_ = false;
  c_mht_clean_ = false;
  c_mht_clean_phi_ = false;
  c_mht_phi_ = false;
  c_mj08_ = false;
  c_mj12_ = false;
  c_mj14_ = false;
  c_mj14_nolep_ = false;
  c_mj40_ = false;
  c_mj50_ = false;
  c_mlsp_ = false;
  c_mm_ = false;
  c_mm_el_miniso_ = false;
  c_mm_el_pt_ = false;
  c_mm_ht_ = false;
  c_mm_jet_eta_ = false;
  c_mm_jet_m_ = false;
  c_mm_jet_phi_ = false;
  c_mm_jet_pt_ = false;
  c_mm_lep_pt_ = false;
  c_mm_met_ = false;
  c_mm_met_phi_ = false;
  c_mm_mj14_lep_ = false;
  c_mm_mj14_nolep_ = false;
  c_mm_mt_ = false;
  c_mm_mu_miniso_ = false;
  c_mm_mu_pt_ = false;
  c_mm_nbm_ = false;
  c_mm_nels_ = false;
  c_mm_njets_ = false;
  c_mm_nleps_ = false;
  c_mm_nmus_ = false;
  c_mt_ = false;
  c_mt2_ = false;
  c_mt2_0mass_ = false;
  c_mt_nohf_ = false;
  c_mt_rebal_ = false;
  c_mt_tru_ = false;
  c_mt_tru_nuw_ = false;
  c_mumu_eta_ = false;
  c_mumu_m_ = false;
  c_mumu_phi_ = false;
  c_mumu_pt_ = false;
  c_mumu_pt1_ = false;
  c_mumu_pt2_ = false;
  c_mumu_w_ = false;
  c_mumuv_eta_ = false;
  c_mumuv_m_ = false;
  c_mumuv_phi_ = false;
  c_mumuv_pt_ = false;
  c_mumuv_pt1_ = false;
  c_mumuv_pt2_ = false;
  c_mumuv_w_ = false;
  c_mus_charge_ = false;
  c_mus_d0_ = false;
  c_mus_dz_ = false;
  c_mus_em_e_ = false;
  c_mus_eta_ = false;
  c_mus_had_e_ = false;
  c_mus_inz_ = false;
  c_mus_inzv_ = false;
  c_mus_isomu18_ = false;
  c_mus_miniso_ = false;
  c_mus_mu50_ = false;
  c_mus_mu8_ = false;
  c_mus_phi_ = false;
  c_mus_pt_ = false;
  c_mus_pterr_ = false;
  c_mus_reliso_ = false;
  c_mus_sig_ = false;
  c_mus_sigid_ = false;
  c_mus_tight_ = false;
  c_mus_tm_ = false;
  c_mus_trk_algo_ = false;
  c_mus_trk_nholes_in_ = false;
  c_mus_trk_nholes_out_ = false;
  c_mus_trk_quality_ = false;
  c_mus_vvvl_ = false;
  c_mus_vvvl_eta_ = false;
  c_mus_vvvl_phi_ = false;
  c_mus_vvvl_pt_ = false;
  c_nbl_ = false;
  c_nbm_ = false;
  c_nbm20_ = false;
  c_nbm40_ = false;
  c_nbm50_ = false;
  c_nbm_ra2_ = false;
  c_nbt_ = false;
  c_nels_ = false;
  c_nels_ele23_ = false;
  c_nels_vvvl_ = false;
  c_nfjets14_ = false;
  c_nfjets40_ = false;
  c_nisr_ = false;
  c_nisr_me_ = false;
  c_njets_ = false;
  c_njets20_ = false;
  c_njets40_ = false;
  c_njets50_ = false;
  c_njets_clean_ = false;
  c_njets_ra2_ = false;
  c_nleps_ = false;
  c_nleps_tm_ = false;
  c_nmus_ = false;
  c_nmus_isomu18_ = false;
  c_nmus_vvvl_ = false;
  c_nonblind_ = false;
  c_nph_ = false;
  c_npv_ = false;
  c_ntks_ = false;
  c_ntruels_ = false;
  c_ntruleps_ = false;
  c_ntrumus_ = false;
  c_ntrupv_ = false;
  c_ntrupv_mean_ = false;
  c_ntrutaush_ = false;
  c_ntrutausl_ = false;
  c_nvels_ = false;
  c_nveto_ = false;
  c_nvleps_ = false;
  c_nvmus_ = false;
  c_onel_ele105_ = false;
  c_onel_ele23_ = false;
  c_onel_ele8_ = false;
  c_onel_vvvl_ = false;
  c_onht_ = false;
  c_onmet_ = false;
  c_onmu_isomu18_ = false;
  c_onmu_mu50_ = false;
  c_onmu_mu8_ = false;
  c_onmu_vvvl_ = false;
  c_onph_ph90_ = false;
  c_pass_ = false;
  c_pass20_ = false;
  c_pass40_ = false;
  c_pass50_ = false;
  c_pass_cschalo_ = false;
  c_pass_ecaldeadcell_ = false;
  c_pass_eebadsc_ = false;
  c_pass_goodv_ = false;
  c_pass_hbhe_ = false;
  c_pass_hbheiso_ = false;
  c_pass_jets_ = false;
  c_pass_jets20_ = false;
  c_pass_jets40_ = false;
  c_pass_jets50_ = false;
  c_pass_jets_nohf_ = false;
  c_pass_jets_ra2_ = false;
  c_pass_jets_tight_ = false;
  c_pass_jets_tight_ra2_ = false;
  c_pass_nohf_ = false;
  c_pass_ra2_ = false;
  c_pass_ra2_badmu_ = false;
  c_ph_eta_ = false;
  c_ph_ph90_ = false;
  c_ph_phi_ = false;
  c_ph_pt_ = false;
  c_ph_tm_ = false;
  c_run_ = false;
  c_st_ = false;
  c_st40_ = false;
  c_st50_ = false;
  c_stitch_ = false;
  c_sys_bctag_ = false;
  c_sys_bctag40_ = false;
  c_sys_bctag_loose_ = false;
  c_sys_fs_bctag_ = false;
  c_sys_fs_bctag40_ = false;
  c_sys_fs_lep_ = false;
  c_sys_fs_udsgtag_ = false;
  c_sys_fs_udsgtag40_ = false;
  c_sys_ht_ = false;
  c_sys_ht40_ = false;
  c_sys_isr_ = false;
  c_sys_lep_ = false;
  c_sys_met_ = false;
  c_sys_mj14_ = false;
  c_sys_mj14_nolep_ = false;
  c_sys_mj40_ = false;
  c_sys_mt_ = false;
  c_sys_muf_ = false;
  c_sys_mur_ = false;
  c_sys_murf_ = false;
  c_sys_nbm_ = false;
  c_sys_nbm40_ = false;
  c_sys_njets_ = false;
  c_sys_njets40_ = false;
  c_sys_pass_ = false;
  c_sys_pass40_ = false;
  c_sys_pu_ = false;
  c_sys_st_ = false;
  c_sys_st40_ = false;
  c_sys_trig_ = false;
  c_sys_udsgtag_ = false;
  c_sys_udsgtag40_ = false;
  c_sys_udsgtag_loose_ = false;
  c_tks_d0_ = false;
  c_tks_dz_ = false;
  c_tks_eta_ = false;
  c_tks_miniso_ = false;
  c_tks_mt_ = false;
  c_tks_mt2_ = false;
  c_tks_pdg_ = false;
  c_tks_phi_ = false;
  c_tks_pt_ = false;
  c_tks_reliso_ = false;
  c_tks_tm_ = false;
  c_trig_ = false;
  c_trig_lep_ = false;
  c_trig_met_ = false;
  c_trig_prescale_ = false;
  c_trig_ra4_ = false;
  c_trig_vvvl_ = false;
  c_type_ = false;
  c_w_btag_ = false;
  c_w_btag40_ = false;
  c_w_btag_loose_ = false;
  c_w_fs_lep_ = false;
  c_w_isr_ = false;
  c_w_lep_ = false;
  c_w_lumi_ = false;
  c_w_pu_ = false;
  c_w_toppt_ = false;
  c_weight_ = false;
  c_weight_rpv_ = false;
  lock_guard<mutex> lock(Multithreading::root_mutex);
  entry_ = chain_->LoadTree(entry);
}

const std::set<std::string> & Baby::FileNames() const{
  return file_names_;
}

// Return integer with sample type
int Baby::SampleType() const{
  return sample_type_;
}

int Baby::SetSampleType(const TString &filename){
  int st = 0;
  if(filename.Contains("SMS"))     st = 10;
  if(filename.Contains("_TTJets")) st = 20;
  if(filename.Contains("_WJets"))  st = 30;
  if(filename.Contains("DYJets"))  st = 40;
  if(filename.Contains("_ZJets"))  st = 41;
  if(filename.Contains("_ST_"))    st = 50;
  if(filename.Contains("_QCD"))    st = 60;
  if(filename.Contains("_TTWJets"))st = 70;
  if(filename.Contains("_TTZ"))    st = 71;
  if(filename.Contains("_TTG"))    st = 72;
  return st;
}

const unique_ptr<TChain> & Baby::GetTree() const{
  return chain_;
}

NamedFunc Baby::GetFunction(const std::string &var_name){
  if(var_name == "dphi1"){
    return ::GetFunction(&Baby::dphi1, "dphi1");
  }else if(var_name == "dphi2"){
    return ::GetFunction(&Baby::dphi2, "dphi2");
  }else if(var_name == "dphi3"){
    return ::GetFunction(&Baby::dphi3, "dphi3");
  }else if(var_name == "dphi4"){
    return ::GetFunction(&Baby::dphi4, "dphi4");
  }else if(var_name == "dphi_wlep"){
    return ::GetFunction(&Baby::dphi_wlep, "dphi_wlep");
  }else if(var_name == "eff_jetid"){
    return ::GetFunction(&Baby::eff_jetid, "eff_jetid");
  }else if(var_name == "eff_trig"){
    return ::GetFunction(&Baby::eff_trig, "eff_trig");
  }else if(var_name == "elel_eta"){
    return ::GetFunction(&Baby::elel_eta, "elel_eta");
  }else if(var_name == "elel_m"){
    return ::GetFunction(&Baby::elel_m, "elel_m");
  }else if(var_name == "elel_phi"){
    return ::GetFunction(&Baby::elel_phi, "elel_phi");
  }else if(var_name == "elel_pt"){
    return ::GetFunction(&Baby::elel_pt, "elel_pt");
  }else if(var_name == "elel_pt1"){
    return ::GetFunction(&Baby::elel_pt1, "elel_pt1");
  }else if(var_name == "elel_pt2"){
    return ::GetFunction(&Baby::elel_pt2, "elel_pt2");
  }else if(var_name == "elel_w"){
    return ::GetFunction(&Baby::elel_w, "elel_w");
  }else if(var_name == "elelv_eta"){
    return ::GetFunction(&Baby::elelv_eta, "elelv_eta");
  }else if(var_name == "elelv_m"){
    return ::GetFunction(&Baby::elelv_m, "elelv_m");
  }else if(var_name == "elelv_phi"){
    return ::GetFunction(&Baby::elelv_phi, "elelv_phi");
  }else if(var_name == "elelv_pt"){
    return ::GetFunction(&Baby::elelv_pt, "elelv_pt");
  }else if(var_name == "elelv_pt1"){
    return ::GetFunction(&Baby::elelv_pt1, "elelv_pt1");
  }else if(var_name == "elelv_pt2"){
    return ::GetFunction(&Baby::elelv_pt2, "elelv_pt2");
  }else if(var_name == "elelv_w"){
    return ::GetFunction(&Baby::elelv_w, "elelv_w");
  }else if(var_name == "elmu_eta"){
    return ::GetFunction(&Baby::elmu_eta, "elmu_eta");
  }else if(var_name == "elmu_m"){
    return ::GetFunction(&Baby::elmu_m, "elmu_m");
  }else if(var_name == "elmu_phi"){
    return ::GetFunction(&Baby::elmu_phi, "elmu_phi");
  }else if(var_name == "elmu_pt"){
    return ::GetFunction(&Baby::elmu_pt, "elmu_pt");
  }else if(var_name == "elmu_pt1"){
    return ::GetFunction(&Baby::elmu_pt1, "elmu_pt1");
  }else if(var_name == "elmu_pt2"){
    return ::GetFunction(&Baby::elmu_pt2, "elmu_pt2");
  }else if(var_name == "elmu_w"){
    return ::GetFunction(&Baby::elmu_w, "elmu_w");
  }else if(var_name == "els_charge"){
    return ::GetFunction(&Baby::els_charge, "els_charge");
  }else if(var_name == "els_d0"){
    return ::GetFunction(&Baby::els_d0, "els_d0");
  }else if(var_name == "els_deta_sctrk"){
    return ::GetFunction(&Baby::els_deta_sctrk, "els_deta_sctrk");
  }else if(var_name == "els_dphi_sctrk"){
    return ::GetFunction(&Baby::els_dphi_sctrk, "els_dphi_sctrk");
  }else if(var_name == "els_dz"){
    return ::GetFunction(&Baby::els_dz, "els_dz");
  }else if(var_name == "els_ele105"){
    return ::GetFunction(&Baby::els_ele105, "els_ele105");
  }else if(var_name == "els_ele23"){
    return ::GetFunction(&Baby::els_ele23, "els_ele23");
  }else if(var_name == "els_ele8"){
    return ::GetFunction(&Baby::els_ele8, "els_ele8");
  }else if(var_name == "els_em_e"){
    return ::GetFunction(&Baby::els_em_e, "els_em_e");
  }else if(var_name == "els_eoverp"){
    return ::GetFunction(&Baby::els_eoverp, "els_eoverp");
  }else if(var_name == "els_eta"){
    return ::GetFunction(&Baby::els_eta, "els_eta");
  }else if(var_name == "els_hovere"){
    return ::GetFunction(&Baby::els_hovere, "els_hovere");
  }else if(var_name == "els_inz"){
    return ::GetFunction(&Baby::els_inz, "els_inz");
  }else if(var_name == "els_inzv"){
    return ::GetFunction(&Baby::els_inzv, "els_inzv");
  }else if(var_name == "els_ip3d"){
    return ::GetFunction(&Baby::els_ip3d, "els_ip3d");
  }else if(var_name == "els_ispf"){
    return ::GetFunction(&Baby::els_ispf, "els_ispf");
  }else if(var_name == "els_miniso"){
    return ::GetFunction(&Baby::els_miniso, "els_miniso");
  }else if(var_name == "els_phi"){
    return ::GetFunction(&Baby::els_phi, "els_phi");
  }else if(var_name == "els_pt"){
    return ::GetFunction(&Baby::els_pt, "els_pt");
  }else if(var_name == "els_reliso"){
    return ::GetFunction(&Baby::els_reliso, "els_reliso");
  }else if(var_name == "els_sceta"){
    return ::GetFunction(&Baby::els_sceta, "els_sceta");
  }else if(var_name == "els_sig"){
    return ::GetFunction(&Baby::els_sig, "els_sig");
  }else if(var_name == "els_sigid"){
    return ::GetFunction(&Baby::els_sigid, "els_sigid");
  }else if(var_name == "els_tight"){
    return ::GetFunction(&Baby::els_tight, "els_tight");
  }else if(var_name == "els_tm"){
    return ::GetFunction(&Baby::els_tm, "els_tm");
  }else if(var_name == "els_trk_nholes"){
    return ::GetFunction(&Baby::els_trk_nholes, "els_trk_nholes");
  }else if(var_name == "els_trk_pt"){
    return ::GetFunction(&Baby::els_trk_pt, "els_trk_pt");
  }else if(var_name == "els_trk_pterr"){
    return ::GetFunction(&Baby::els_trk_pterr, "els_trk_pterr");
  }else if(var_name == "els_vvvl"){
    return ::GetFunction(&Baby::els_vvvl, "els_vvvl");
  }else if(var_name == "els_vvvl_eta"){
    return ::GetFunction(&Baby::els_vvvl_eta, "els_vvvl_eta");
  }else if(var_name == "els_vvvl_phi"){
    return ::GetFunction(&Baby::els_vvvl_phi, "els_vvvl_phi");
  }else if(var_name == "els_vvvl_pt"){
    return ::GetFunction(&Baby::els_vvvl_pt, "els_vvvl_pt");
  }else if(var_name == "event"){
    return ::GetFunction(&Baby::event, "event");
  }else if(var_name == "fjets14_eta"){
    return ::GetFunction(&Baby::fjets14_eta, "fjets14_eta");
  }else if(var_name == "fjets14_m"){
    return ::GetFunction(&Baby::fjets14_m, "fjets14_m");
  }else if(var_name == "fjets14_nconst"){
    return ::GetFunction(&Baby::fjets14_nconst, "fjets14_nconst");
  }else if(var_name == "fjets14_phi"){
    return ::GetFunction(&Baby::fjets14_phi, "fjets14_phi");
  }else if(var_name == "fjets14_pt"){
    return ::GetFunction(&Baby::fjets14_pt, "fjets14_pt");
  }else if(var_name == "fjets40_eta"){
    return ::GetFunction(&Baby::fjets40_eta, "fjets40_eta");
  }else if(var_name == "fjets40_m"){
    return ::GetFunction(&Baby::fjets40_m, "fjets40_m");
  }else if(var_name == "fjets40_nconst"){
    return ::GetFunction(&Baby::fjets40_nconst, "fjets40_nconst");
  }else if(var_name == "fjets40_phi"){
    return ::GetFunction(&Baby::fjets40_phi, "fjets40_phi");
  }else if(var_name == "fjets40_pt"){
    return ::GetFunction(&Baby::fjets40_pt, "fjets40_pt");
  }else if(var_name == "fromGS"){
    return ::GetFunction(&Baby::fromGS, "fromGS");
  }else if(var_name == "hig1_eta"){
    return ::GetFunction(&Baby::hig1_eta, "hig1_eta");
  }else if(var_name == "hig1_m"){
    return ::GetFunction(&Baby::hig1_m, "hig1_m");
  }else if(var_name == "hig1_phi"){
    return ::GetFunction(&Baby::hig1_phi, "hig1_phi");
  }else if(var_name == "hig1_pt"){
    return ::GetFunction(&Baby::hig1_pt, "hig1_pt");
  }else if(var_name == "hig2_eta"){
    return ::GetFunction(&Baby::hig2_eta, "hig2_eta");
  }else if(var_name == "hig2_m"){
    return ::GetFunction(&Baby::hig2_m, "hig2_m");
  }else if(var_name == "hig2_phi"){
    return ::GetFunction(&Baby::hig2_phi, "hig2_phi");
  }else if(var_name == "hig2_pt"){
    return ::GetFunction(&Baby::hig2_pt, "hig2_pt");
  }else if(var_name == "hig_am"){
    return ::GetFunction(&Baby::hig_am, "hig_am");
  }else if(var_name == "hig_bin"){
    return ::GetFunction(&Baby::hig_bin, "hig_bin");
  }else if(var_name == "hig_dm"){
    return ::GetFunction(&Baby::hig_dm, "hig_dm");
  }else if(var_name == "hig_dphi"){
    return ::GetFunction(&Baby::hig_dphi, "hig_dphi");
  }else if(var_name == "hig_drmax"){
    return ::GetFunction(&Baby::hig_drmax, "hig_drmax");
  }else if(var_name == "ht"){
    return ::GetFunction(&Baby::ht, "ht");
  }else if(var_name == "ht40"){
    return ::GetFunction(&Baby::ht40, "ht40");
  }else if(var_name == "ht50"){
    return ::GetFunction(&Baby::ht50, "ht50");
  }else if(var_name == "ht_clean"){
    return ::GetFunction(&Baby::ht_clean, "ht_clean");
  }else if(var_name == "ht_hlt"){
    return ::GetFunction(&Baby::ht_hlt, "ht_hlt");
  }else if(var_name == "ht_isr_me"){
    return ::GetFunction(&Baby::ht_isr_me, "ht_isr_me");
  }else if(var_name == "ht_ra2"){
    return ::GetFunction(&Baby::ht_ra2, "ht_ra2");
  }else if(var_name == "ht_tru"){
    return ::GetFunction(&Baby::ht_tru, "ht_tru");
  }else if(var_name == "htx"){
    return ::GetFunction(&Baby::htx, "htx");
  }else if(var_name == "htx40"){
    return ::GetFunction(&Baby::htx40, "htx40");
  }else if(var_name == "htx50"){
    return ::GetFunction(&Baby::htx50, "htx50");
  }else if(var_name == "isr_tru_eta"){
    return ::GetFunction(&Baby::isr_tru_eta, "isr_tru_eta");
  }else if(var_name == "isr_tru_phi"){
    return ::GetFunction(&Baby::isr_tru_phi, "isr_tru_phi");
  }else if(var_name == "isr_tru_pt"){
    return ::GetFunction(&Baby::isr_tru_pt, "isr_tru_pt");
  }else if(var_name == "jetmismeas"){
    return ::GetFunction(&Baby::jetmismeas, "jetmismeas");
  }else if(var_name == "jets_csv"){
    return ::GetFunction(&Baby::jets_csv, "jets_csv");
  }else if(var_name == "jets_eta"){
    return ::GetFunction(&Baby::jets_eta, "jets_eta");
  }else if(var_name == "jets_fjet08_index"){
    return ::GetFunction(&Baby::jets_fjet08_index, "jets_fjet08_index");
  }else if(var_name == "jets_fjet12_index"){
    return ::GetFunction(&Baby::jets_fjet12_index, "jets_fjet12_index");
  }else if(var_name == "jets_fjet14_index"){
    return ::GetFunction(&Baby::jets_fjet14_index, "jets_fjet14_index");
  }else if(var_name == "jets_fjet14_nolep_index"){
    return ::GetFunction(&Baby::jets_fjet14_nolep_index, "jets_fjet14_nolep_index");
  }else if(var_name == "jets_fjet40_index"){
    return ::GetFunction(&Baby::jets_fjet40_index, "jets_fjet40_index");
  }else if(var_name == "jets_fjet50_index"){
    return ::GetFunction(&Baby::jets_fjet50_index, "jets_fjet50_index");
  }else if(var_name == "jets_h1"){
    return ::GetFunction(&Baby::jets_h1, "jets_h1");
  }else if(var_name == "jets_h2"){
    return ::GetFunction(&Baby::jets_h2, "jets_h2");
  }else if(var_name == "jets_hflavor"){
    return ::GetFunction(&Baby::jets_hflavor, "jets_hflavor");
  }else if(var_name == "jets_isisr"){
    return ::GetFunction(&Baby::jets_isisr, "jets_isisr");
  }else if(var_name == "jets_islep"){
    return ::GetFunction(&Baby::jets_islep, "jets_islep");
  }else if(var_name == "jets_m"){
    return ::GetFunction(&Baby::jets_m, "jets_m");
  }else if(var_name == "jets_phi"){
    return ::GetFunction(&Baby::jets_phi, "jets_phi");
  }else if(var_name == "jets_pt"){
    return ::GetFunction(&Baby::jets_pt, "jets_pt");
  }else if(var_name == "jets_pt_res"){
    return ::GetFunction(&Baby::jets_pt_res, "jets_pt_res");
  }else if(var_name == "jetsys_eta"){
    return ::GetFunction(&Baby::jetsys_eta, "jetsys_eta");
  }else if(var_name == "jetsys_m"){
    return ::GetFunction(&Baby::jetsys_m, "jetsys_m");
  }else if(var_name == "jetsys_nob_eta"){
    return ::GetFunction(&Baby::jetsys_nob_eta, "jetsys_nob_eta");
  }else if(var_name == "jetsys_nob_m"){
    return ::GetFunction(&Baby::jetsys_nob_m, "jetsys_nob_m");
  }else if(var_name == "jetsys_nob_phi"){
    return ::GetFunction(&Baby::jetsys_nob_phi, "jetsys_nob_phi");
  }else if(var_name == "jetsys_nob_pt"){
    return ::GetFunction(&Baby::jetsys_nob_pt, "jetsys_nob_pt");
  }else if(var_name == "jetsys_phi"){
    return ::GetFunction(&Baby::jetsys_phi, "jetsys_phi");
  }else if(var_name == "jetsys_pt"){
    return ::GetFunction(&Baby::jetsys_pt, "jetsys_pt");
  }else if(var_name == "json12p9"){
    return ::GetFunction(&Baby::json12p9, "json12p9");
  }else if(var_name == "json2p6"){
    return ::GetFunction(&Baby::json2p6, "json2p6");
  }else if(var_name == "json4p0"){
    return ::GetFunction(&Baby::json4p0, "json4p0");
  }else if(var_name == "json7p65"){
    return ::GetFunction(&Baby::json7p65, "json7p65");
  }else if(var_name == "leps_eta"){
    return ::GetFunction(&Baby::leps_eta, "leps_eta");
  }else if(var_name == "leps_id"){
    return ::GetFunction(&Baby::leps_id, "leps_id");
  }else if(var_name == "leps_phi"){
    return ::GetFunction(&Baby::leps_phi, "leps_phi");
  }else if(var_name == "leps_pt"){
    return ::GetFunction(&Baby::leps_pt, "leps_pt");
  }else if(var_name == "low_dphi"){
    return ::GetFunction(&Baby::low_dphi, "low_dphi");
  }else if(var_name == "lumiblock"){
    return ::GetFunction(&Baby::lumiblock, "lumiblock");
  }else if(var_name == "m_tt"){
    return ::GetFunction(&Baby::m_tt, "m_tt");
  }else if(var_name == "mc_eta"){
    return ::GetFunction(&Baby::mc_eta, "mc_eta");
  }else if(var_name == "mc_id"){
    return ::GetFunction(&Baby::mc_id, "mc_id");
  }else if(var_name == "mc_mass"){
    return ::GetFunction(&Baby::mc_mass, "mc_mass");
  }else if(var_name == "mc_mom"){
    return ::GetFunction(&Baby::mc_mom, "mc_mom");
  }else if(var_name == "mc_momidx"){
    return ::GetFunction(&Baby::mc_momidx, "mc_momidx");
  }else if(var_name == "mc_phi"){
    return ::GetFunction(&Baby::mc_phi, "mc_phi");
  }else if(var_name == "mc_pt"){
    return ::GetFunction(&Baby::mc_pt, "mc_pt");
  }else if(var_name == "mc_status"){
    return ::GetFunction(&Baby::mc_status, "mc_status");
  }else if(var_name == "mct"){
    return ::GetFunction(&Baby::mct, "mct");
  }else if(var_name == "met"){
    return ::GetFunction(&Baby::met, "met");
  }else if(var_name == "met_calo"){
    return ::GetFunction(&Baby::met_calo, "met_calo");
  }else if(var_name == "met_calo_phi"){
    return ::GetFunction(&Baby::met_calo_phi, "met_calo_phi");
  }else if(var_name == "met_mini"){
    return ::GetFunction(&Baby::met_mini, "met_mini");
  }else if(var_name == "met_mini_phi"){
    return ::GetFunction(&Baby::met_mini_phi, "met_mini_phi");
  }else if(var_name == "met_nohf"){
    return ::GetFunction(&Baby::met_nohf, "met_nohf");
  }else if(var_name == "met_nohf_phi"){
    return ::GetFunction(&Baby::met_nohf_phi, "met_nohf_phi");
  }else if(var_name == "met_phi"){
    return ::GetFunction(&Baby::met_phi, "met_phi");
  }else if(var_name == "met_raw"){
    return ::GetFunction(&Baby::met_raw, "met_raw");
  }else if(var_name == "met_raw_phi"){
    return ::GetFunction(&Baby::met_raw_phi, "met_raw_phi");
  }else if(var_name == "met_rebal"){
    return ::GetFunction(&Baby::met_rebal, "met_rebal");
  }else if(var_name == "met_tru"){
    return ::GetFunction(&Baby::met_tru, "met_tru");
  }else if(var_name == "met_tru_nuw"){
    return ::GetFunction(&Baby::met_tru_nuw, "met_tru_nuw");
  }else if(var_name == "met_tru_nuw_phi"){
    return ::GetFunction(&Baby::met_tru_nuw_phi, "met_tru_nuw_phi");
  }else if(var_name == "met_tru_phi"){
    return ::GetFunction(&Baby::met_tru_phi, "met_tru_phi");
  }else if(var_name == "mgluino"){
    return ::GetFunction(&Baby::mgluino, "mgluino");
  }else if(var_name == "mht"){
    return ::GetFunction(&Baby::mht, "mht");
  }else if(var_name == "mht_clean"){
    return ::GetFunction(&Baby::mht_clean, "mht_clean");
  }else if(var_name == "mht_clean_phi"){
    return ::GetFunction(&Baby::mht_clean_phi, "mht_clean_phi");
  }else if(var_name == "mht_phi"){
    return ::GetFunction(&Baby::mht_phi, "mht_phi");
  }else if(var_name == "mj08"){
    return ::GetFunction(&Baby::mj08, "mj08");
  }else if(var_name == "mj12"){
    return ::GetFunction(&Baby::mj12, "mj12");
  }else if(var_name == "mj14"){
    return ::GetFunction(&Baby::mj14, "mj14");
  }else if(var_name == "mj14_nolep"){
    return ::GetFunction(&Baby::mj14_nolep, "mj14_nolep");
  }else if(var_name == "mj40"){
    return ::GetFunction(&Baby::mj40, "mj40");
  }else if(var_name == "mj50"){
    return ::GetFunction(&Baby::mj50, "mj50");
  }else if(var_name == "mlsp"){
    return ::GetFunction(&Baby::mlsp, "mlsp");
  }else if(var_name == "mm"){
    return ::GetFunction(&Baby::mm, "mm");
  }else if(var_name == "mm_el_miniso"){
    return ::GetFunction(&Baby::mm_el_miniso, "mm_el_miniso");
  }else if(var_name == "mm_el_pt"){
    return ::GetFunction(&Baby::mm_el_pt, "mm_el_pt");
  }else if(var_name == "mm_ht"){
    return ::GetFunction(&Baby::mm_ht, "mm_ht");
  }else if(var_name == "mm_jet_eta"){
    return ::GetFunction(&Baby::mm_jet_eta, "mm_jet_eta");
  }else if(var_name == "mm_jet_m"){
    return ::GetFunction(&Baby::mm_jet_m, "mm_jet_m");
  }else if(var_name == "mm_jet_phi"){
    return ::GetFunction(&Baby::mm_jet_phi, "mm_jet_phi");
  }else if(var_name == "mm_jet_pt"){
    return ::GetFunction(&Baby::mm_jet_pt, "mm_jet_pt");
  }else if(var_name == "mm_lep_pt"){
    return ::GetFunction(&Baby::mm_lep_pt, "mm_lep_pt");
  }else if(var_name == "mm_met"){
    return ::GetFunction(&Baby::mm_met, "mm_met");
  }else if(var_name == "mm_met_phi"){
    return ::GetFunction(&Baby::mm_met_phi, "mm_met_phi");
  }else if(var_name == "mm_mj14_lep"){
    return ::GetFunction(&Baby::mm_mj14_lep, "mm_mj14_lep");
  }else if(var_name == "mm_mj14_nolep"){
    return ::GetFunction(&Baby::mm_mj14_nolep, "mm_mj14_nolep");
  }else if(var_name == "mm_mt"){
    return ::GetFunction(&Baby::mm_mt, "mm_mt");
  }else if(var_name == "mm_mu_miniso"){
    return ::GetFunction(&Baby::mm_mu_miniso, "mm_mu_miniso");
  }else if(var_name == "mm_mu_pt"){
    return ::GetFunction(&Baby::mm_mu_pt, "mm_mu_pt");
  }else if(var_name == "mm_nbm"){
    return ::GetFunction(&Baby::mm_nbm, "mm_nbm");
  }else if(var_name == "mm_nels"){
    return ::GetFunction(&Baby::mm_nels, "mm_nels");
  }else if(var_name == "mm_njets"){
    return ::GetFunction(&Baby::mm_njets, "mm_njets");
  }else if(var_name == "mm_nleps"){
    return ::GetFunction(&Baby::mm_nleps, "mm_nleps");
  }else if(var_name == "mm_nmus"){
    return ::GetFunction(&Baby::mm_nmus, "mm_nmus");
  }else if(var_name == "mt"){
    return ::GetFunction(&Baby::mt, "mt");
  }else if(var_name == "mt2"){
    return ::GetFunction(&Baby::mt2, "mt2");
  }else if(var_name == "mt2_0mass"){
    return ::GetFunction(&Baby::mt2_0mass, "mt2_0mass");
  }else if(var_name == "mt_nohf"){
    return ::GetFunction(&Baby::mt_nohf, "mt_nohf");
  }else if(var_name == "mt_rebal"){
    return ::GetFunction(&Baby::mt_rebal, "mt_rebal");
  }else if(var_name == "mt_tru"){
    return ::GetFunction(&Baby::mt_tru, "mt_tru");
  }else if(var_name == "mt_tru_nuw"){
    return ::GetFunction(&Baby::mt_tru_nuw, "mt_tru_nuw");
  }else if(var_name == "mumu_eta"){
    return ::GetFunction(&Baby::mumu_eta, "mumu_eta");
  }else if(var_name == "mumu_m"){
    return ::GetFunction(&Baby::mumu_m, "mumu_m");
  }else if(var_name == "mumu_phi"){
    return ::GetFunction(&Baby::mumu_phi, "mumu_phi");
  }else if(var_name == "mumu_pt"){
    return ::GetFunction(&Baby::mumu_pt, "mumu_pt");
  }else if(var_name == "mumu_pt1"){
    return ::GetFunction(&Baby::mumu_pt1, "mumu_pt1");
  }else if(var_name == "mumu_pt2"){
    return ::GetFunction(&Baby::mumu_pt2, "mumu_pt2");
  }else if(var_name == "mumu_w"){
    return ::GetFunction(&Baby::mumu_w, "mumu_w");
  }else if(var_name == "mumuv_eta"){
    return ::GetFunction(&Baby::mumuv_eta, "mumuv_eta");
  }else if(var_name == "mumuv_m"){
    return ::GetFunction(&Baby::mumuv_m, "mumuv_m");
  }else if(var_name == "mumuv_phi"){
    return ::GetFunction(&Baby::mumuv_phi, "mumuv_phi");
  }else if(var_name == "mumuv_pt"){
    return ::GetFunction(&Baby::mumuv_pt, "mumuv_pt");
  }else if(var_name == "mumuv_pt1"){
    return ::GetFunction(&Baby::mumuv_pt1, "mumuv_pt1");
  }else if(var_name == "mumuv_pt2"){
    return ::GetFunction(&Baby::mumuv_pt2, "mumuv_pt2");
  }else if(var_name == "mumuv_w"){
    return ::GetFunction(&Baby::mumuv_w, "mumuv_w");
  }else if(var_name == "mus_charge"){
    return ::GetFunction(&Baby::mus_charge, "mus_charge");
  }else if(var_name == "mus_d0"){
    return ::GetFunction(&Baby::mus_d0, "mus_d0");
  }else if(var_name == "mus_dz"){
    return ::GetFunction(&Baby::mus_dz, "mus_dz");
  }else if(var_name == "mus_em_e"){
    return ::GetFunction(&Baby::mus_em_e, "mus_em_e");
  }else if(var_name == "mus_eta"){
    return ::GetFunction(&Baby::mus_eta, "mus_eta");
  }else if(var_name == "mus_had_e"){
    return ::GetFunction(&Baby::mus_had_e, "mus_had_e");
  }else if(var_name == "mus_inz"){
    return ::GetFunction(&Baby::mus_inz, "mus_inz");
  }else if(var_name == "mus_inzv"){
    return ::GetFunction(&Baby::mus_inzv, "mus_inzv");
  }else if(var_name == "mus_isomu18"){
    return ::GetFunction(&Baby::mus_isomu18, "mus_isomu18");
  }else if(var_name == "mus_miniso"){
    return ::GetFunction(&Baby::mus_miniso, "mus_miniso");
  }else if(var_name == "mus_mu50"){
    return ::GetFunction(&Baby::mus_mu50, "mus_mu50");
  }else if(var_name == "mus_mu8"){
    return ::GetFunction(&Baby::mus_mu8, "mus_mu8");
  }else if(var_name == "mus_phi"){
    return ::GetFunction(&Baby::mus_phi, "mus_phi");
  }else if(var_name == "mus_pt"){
    return ::GetFunction(&Baby::mus_pt, "mus_pt");
  }else if(var_name == "mus_pterr"){
    return ::GetFunction(&Baby::mus_pterr, "mus_pterr");
  }else if(var_name == "mus_reliso"){
    return ::GetFunction(&Baby::mus_reliso, "mus_reliso");
  }else if(var_name == "mus_sig"){
    return ::GetFunction(&Baby::mus_sig, "mus_sig");
  }else if(var_name == "mus_sigid"){
    return ::GetFunction(&Baby::mus_sigid, "mus_sigid");
  }else if(var_name == "mus_tight"){
    return ::GetFunction(&Baby::mus_tight, "mus_tight");
  }else if(var_name == "mus_tm"){
    return ::GetFunction(&Baby::mus_tm, "mus_tm");
  }else if(var_name == "mus_trk_algo"){
    return ::GetFunction(&Baby::mus_trk_algo, "mus_trk_algo");
  }else if(var_name == "mus_trk_nholes_in"){
    return ::GetFunction(&Baby::mus_trk_nholes_in, "mus_trk_nholes_in");
  }else if(var_name == "mus_trk_nholes_out"){
    return ::GetFunction(&Baby::mus_trk_nholes_out, "mus_trk_nholes_out");
  }else if(var_name == "mus_trk_quality"){
    return ::GetFunction(&Baby::mus_trk_quality, "mus_trk_quality");
  }else if(var_name == "mus_vvvl"){
    return ::GetFunction(&Baby::mus_vvvl, "mus_vvvl");
  }else if(var_name == "mus_vvvl_eta"){
    return ::GetFunction(&Baby::mus_vvvl_eta, "mus_vvvl_eta");
  }else if(var_name == "mus_vvvl_phi"){
    return ::GetFunction(&Baby::mus_vvvl_phi, "mus_vvvl_phi");
  }else if(var_name == "mus_vvvl_pt"){
    return ::GetFunction(&Baby::mus_vvvl_pt, "mus_vvvl_pt");
  }else if(var_name == "nbl"){
    return ::GetFunction(&Baby::nbl, "nbl");
  }else if(var_name == "nbm"){
    return ::GetFunction(&Baby::nbm, "nbm");
  }else if(var_name == "nbm20"){
    return ::GetFunction(&Baby::nbm20, "nbm20");
  }else if(var_name == "nbm40"){
    return ::GetFunction(&Baby::nbm40, "nbm40");
  }else if(var_name == "nbm50"){
    return ::GetFunction(&Baby::nbm50, "nbm50");
  }else if(var_name == "nbm_ra2"){
    return ::GetFunction(&Baby::nbm_ra2, "nbm_ra2");
  }else if(var_name == "nbt"){
    return ::GetFunction(&Baby::nbt, "nbt");
  }else if(var_name == "nels"){
    return ::GetFunction(&Baby::nels, "nels");
  }else if(var_name == "nels_ele23"){
    return ::GetFunction(&Baby::nels_ele23, "nels_ele23");
  }else if(var_name == "nels_vvvl"){
    return ::GetFunction(&Baby::nels_vvvl, "nels_vvvl");
  }else if(var_name == "nfjets14"){
    return ::GetFunction(&Baby::nfjets14, "nfjets14");
  }else if(var_name == "nfjets40"){
    return ::GetFunction(&Baby::nfjets40, "nfjets40");
  }else if(var_name == "nisr"){
    return ::GetFunction(&Baby::nisr, "nisr");
  }else if(var_name == "nisr_me"){
    return ::GetFunction(&Baby::nisr_me, "nisr_me");
  }else if(var_name == "njets"){
    return ::GetFunction(&Baby::njets, "njets");
  }else if(var_name == "njets20"){
    return ::GetFunction(&Baby::njets20, "njets20");
  }else if(var_name == "njets40"){
    return ::GetFunction(&Baby::njets40, "njets40");
  }else if(var_name == "njets50"){
    return ::GetFunction(&Baby::njets50, "njets50");
  }else if(var_name == "njets_clean"){
    return ::GetFunction(&Baby::njets_clean, "njets_clean");
  }else if(var_name == "njets_ra2"){
    return ::GetFunction(&Baby::njets_ra2, "njets_ra2");
  }else if(var_name == "nleps"){
    return ::GetFunction(&Baby::nleps, "nleps");
  }else if(var_name == "nleps_tm"){
    return ::GetFunction(&Baby::nleps_tm, "nleps_tm");
  }else if(var_name == "nmus"){
    return ::GetFunction(&Baby::nmus, "nmus");
  }else if(var_name == "nmus_isomu18"){
    return ::GetFunction(&Baby::nmus_isomu18, "nmus_isomu18");
  }else if(var_name == "nmus_vvvl"){
    return ::GetFunction(&Baby::nmus_vvvl, "nmus_vvvl");
  }else if(var_name == "nonblind"){
    return ::GetFunction(&Baby::nonblind, "nonblind");
  }else if(var_name == "nph"){
    return ::GetFunction(&Baby::nph, "nph");
  }else if(var_name == "npv"){
    return ::GetFunction(&Baby::npv, "npv");
  }else if(var_name == "ntks"){
    return ::GetFunction(&Baby::ntks, "ntks");
  }else if(var_name == "ntruels"){
    return ::GetFunction(&Baby::ntruels, "ntruels");
  }else if(var_name == "ntruleps"){
    return ::GetFunction(&Baby::ntruleps, "ntruleps");
  }else if(var_name == "ntrumus"){
    return ::GetFunction(&Baby::ntrumus, "ntrumus");
  }else if(var_name == "ntrupv"){
    return ::GetFunction(&Baby::ntrupv, "ntrupv");
  }else if(var_name == "ntrupv_mean"){
    return ::GetFunction(&Baby::ntrupv_mean, "ntrupv_mean");
  }else if(var_name == "ntrutaush"){
    return ::GetFunction(&Baby::ntrutaush, "ntrutaush");
  }else if(var_name == "ntrutausl"){
    return ::GetFunction(&Baby::ntrutausl, "ntrutausl");
  }else if(var_name == "nvels"){
    return ::GetFunction(&Baby::nvels, "nvels");
  }else if(var_name == "nveto"){
    return ::GetFunction(&Baby::nveto, "nveto");
  }else if(var_name == "nvleps"){
    return ::GetFunction(&Baby::nvleps, "nvleps");
  }else if(var_name == "nvmus"){
    return ::GetFunction(&Baby::nvmus, "nvmus");
  }else if(var_name == "onel_ele105"){
    return ::GetFunction(&Baby::onel_ele105, "onel_ele105");
  }else if(var_name == "onel_ele23"){
    return ::GetFunction(&Baby::onel_ele23, "onel_ele23");
  }else if(var_name == "onel_ele8"){
    return ::GetFunction(&Baby::onel_ele8, "onel_ele8");
  }else if(var_name == "onel_vvvl"){
    return ::GetFunction(&Baby::onel_vvvl, "onel_vvvl");
  }else if(var_name == "onht"){
    return ::GetFunction(&Baby::onht, "onht");
  }else if(var_name == "onmet"){
    return ::GetFunction(&Baby::onmet, "onmet");
  }else if(var_name == "onmu_isomu18"){
    return ::GetFunction(&Baby::onmu_isomu18, "onmu_isomu18");
  }else if(var_name == "onmu_mu50"){
    return ::GetFunction(&Baby::onmu_mu50, "onmu_mu50");
  }else if(var_name == "onmu_mu8"){
    return ::GetFunction(&Baby::onmu_mu8, "onmu_mu8");
  }else if(var_name == "onmu_vvvl"){
    return ::GetFunction(&Baby::onmu_vvvl, "onmu_vvvl");
  }else if(var_name == "onph_ph90"){
    return ::GetFunction(&Baby::onph_ph90, "onph_ph90");
  }else if(var_name == "pass"){
    return ::GetFunction(&Baby::pass, "pass");
  }else if(var_name == "pass20"){
    return ::GetFunction(&Baby::pass20, "pass20");
  }else if(var_name == "pass40"){
    return ::GetFunction(&Baby::pass40, "pass40");
  }else if(var_name == "pass50"){
    return ::GetFunction(&Baby::pass50, "pass50");
  }else if(var_name == "pass_cschalo"){
    return ::GetFunction(&Baby::pass_cschalo, "pass_cschalo");
  }else if(var_name == "pass_ecaldeadcell"){
    return ::GetFunction(&Baby::pass_ecaldeadcell, "pass_ecaldeadcell");
  }else if(var_name == "pass_eebadsc"){
    return ::GetFunction(&Baby::pass_eebadsc, "pass_eebadsc");
  }else if(var_name == "pass_goodv"){
    return ::GetFunction(&Baby::pass_goodv, "pass_goodv");
  }else if(var_name == "pass_hbhe"){
    return ::GetFunction(&Baby::pass_hbhe, "pass_hbhe");
  }else if(var_name == "pass_hbheiso"){
    return ::GetFunction(&Baby::pass_hbheiso, "pass_hbheiso");
  }else if(var_name == "pass_jets"){
    return ::GetFunction(&Baby::pass_jets, "pass_jets");
  }else if(var_name == "pass_jets20"){
    return ::GetFunction(&Baby::pass_jets20, "pass_jets20");
  }else if(var_name == "pass_jets40"){
    return ::GetFunction(&Baby::pass_jets40, "pass_jets40");
  }else if(var_name == "pass_jets50"){
    return ::GetFunction(&Baby::pass_jets50, "pass_jets50");
  }else if(var_name == "pass_jets_nohf"){
    return ::GetFunction(&Baby::pass_jets_nohf, "pass_jets_nohf");
  }else if(var_name == "pass_jets_ra2"){
    return ::GetFunction(&Baby::pass_jets_ra2, "pass_jets_ra2");
  }else if(var_name == "pass_jets_tight"){
    return ::GetFunction(&Baby::pass_jets_tight, "pass_jets_tight");
  }else if(var_name == "pass_jets_tight_ra2"){
    return ::GetFunction(&Baby::pass_jets_tight_ra2, "pass_jets_tight_ra2");
  }else if(var_name == "pass_nohf"){
    return ::GetFunction(&Baby::pass_nohf, "pass_nohf");
  }else if(var_name == "pass_ra2"){
    return ::GetFunction(&Baby::pass_ra2, "pass_ra2");
  }else if(var_name == "pass_ra2_badmu"){
    return ::GetFunction(&Baby::pass_ra2_badmu, "pass_ra2_badmu");
  }else if(var_name == "ph_eta"){
    return ::GetFunction(&Baby::ph_eta, "ph_eta");
  }else if(var_name == "ph_ph90"){
    return ::GetFunction(&Baby::ph_ph90, "ph_ph90");
  }else if(var_name == "ph_phi"){
    return ::GetFunction(&Baby::ph_phi, "ph_phi");
  }else if(var_name == "ph_pt"){
    return ::GetFunction(&Baby::ph_pt, "ph_pt");
  }else if(var_name == "ph_tm"){
    return ::GetFunction(&Baby::ph_tm, "ph_tm");
  }else if(var_name == "run"){
    return ::GetFunction(&Baby::run, "run");
  }else if(var_name == "st"){
    return ::GetFunction(&Baby::st, "st");
  }else if(var_name == "st40"){
    return ::GetFunction(&Baby::st40, "st40");
  }else if(var_name == "st50"){
    return ::GetFunction(&Baby::st50, "st50");
  }else if(var_name == "stitch"){
    return ::GetFunction(&Baby::stitch, "stitch");
  }else if(var_name == "sys_bctag"){
    return ::GetFunction(&Baby::sys_bctag, "sys_bctag");
  }else if(var_name == "sys_bctag40"){
    return ::GetFunction(&Baby::sys_bctag40, "sys_bctag40");
  }else if(var_name == "sys_bctag_loose"){
    return ::GetFunction(&Baby::sys_bctag_loose, "sys_bctag_loose");
  }else if(var_name == "sys_fs_bctag"){
    return ::GetFunction(&Baby::sys_fs_bctag, "sys_fs_bctag");
  }else if(var_name == "sys_fs_bctag40"){
    return ::GetFunction(&Baby::sys_fs_bctag40, "sys_fs_bctag40");
  }else if(var_name == "sys_fs_lep"){
    return ::GetFunction(&Baby::sys_fs_lep, "sys_fs_lep");
  }else if(var_name == "sys_fs_udsgtag"){
    return ::GetFunction(&Baby::sys_fs_udsgtag, "sys_fs_udsgtag");
  }else if(var_name == "sys_fs_udsgtag40"){
    return ::GetFunction(&Baby::sys_fs_udsgtag40, "sys_fs_udsgtag40");
  }else if(var_name == "sys_ht"){
    return ::GetFunction(&Baby::sys_ht, "sys_ht");
  }else if(var_name == "sys_ht40"){
    return ::GetFunction(&Baby::sys_ht40, "sys_ht40");
  }else if(var_name == "sys_isr"){
    return ::GetFunction(&Baby::sys_isr, "sys_isr");
  }else if(var_name == "sys_lep"){
    return ::GetFunction(&Baby::sys_lep, "sys_lep");
  }else if(var_name == "sys_met"){
    return ::GetFunction(&Baby::sys_met, "sys_met");
  }else if(var_name == "sys_mj14"){
    return ::GetFunction(&Baby::sys_mj14, "sys_mj14");
  }else if(var_name == "sys_mj14_nolep"){
    return ::GetFunction(&Baby::sys_mj14_nolep, "sys_mj14_nolep");
  }else if(var_name == "sys_mj40"){
    return ::GetFunction(&Baby::sys_mj40, "sys_mj40");
  }else if(var_name == "sys_mt"){
    return ::GetFunction(&Baby::sys_mt, "sys_mt");
  }else if(var_name == "sys_muf"){
    return ::GetFunction(&Baby::sys_muf, "sys_muf");
  }else if(var_name == "sys_mur"){
    return ::GetFunction(&Baby::sys_mur, "sys_mur");
  }else if(var_name == "sys_murf"){
    return ::GetFunction(&Baby::sys_murf, "sys_murf");
  }else if(var_name == "sys_nbm"){
    return ::GetFunction(&Baby::sys_nbm, "sys_nbm");
  }else if(var_name == "sys_nbm40"){
    return ::GetFunction(&Baby::sys_nbm40, "sys_nbm40");
  }else if(var_name == "sys_njets"){
    return ::GetFunction(&Baby::sys_njets, "sys_njets");
  }else if(var_name == "sys_njets40"){
    return ::GetFunction(&Baby::sys_njets40, "sys_njets40");
  }else if(var_name == "sys_pass"){
    return ::GetFunction(&Baby::sys_pass, "sys_pass");
  }else if(var_name == "sys_pass40"){
    return ::GetFunction(&Baby::sys_pass40, "sys_pass40");
  }else if(var_name == "sys_pu"){
    return ::GetFunction(&Baby::sys_pu, "sys_pu");
  }else if(var_name == "sys_st"){
    return ::GetFunction(&Baby::sys_st, "sys_st");
  }else if(var_name == "sys_st40"){
    return ::GetFunction(&Baby::sys_st40, "sys_st40");
  }else if(var_name == "sys_trig"){
    return ::GetFunction(&Baby::sys_trig, "sys_trig");
  }else if(var_name == "sys_udsgtag"){
    return ::GetFunction(&Baby::sys_udsgtag, "sys_udsgtag");
  }else if(var_name == "sys_udsgtag40"){
    return ::GetFunction(&Baby::sys_udsgtag40, "sys_udsgtag40");
  }else if(var_name == "sys_udsgtag_loose"){
    return ::GetFunction(&Baby::sys_udsgtag_loose, "sys_udsgtag_loose");
  }else if(var_name == "tks_d0"){
    return ::GetFunction(&Baby::tks_d0, "tks_d0");
  }else if(var_name == "tks_dz"){
    return ::GetFunction(&Baby::tks_dz, "tks_dz");
  }else if(var_name == "tks_eta"){
    return ::GetFunction(&Baby::tks_eta, "tks_eta");
  }else if(var_name == "tks_miniso"){
    return ::GetFunction(&Baby::tks_miniso, "tks_miniso");
  }else if(var_name == "tks_mt"){
    return ::GetFunction(&Baby::tks_mt, "tks_mt");
  }else if(var_name == "tks_mt2"){
    return ::GetFunction(&Baby::tks_mt2, "tks_mt2");
  }else if(var_name == "tks_pdg"){
    return ::GetFunction(&Baby::tks_pdg, "tks_pdg");
  }else if(var_name == "tks_phi"){
    return ::GetFunction(&Baby::tks_phi, "tks_phi");
  }else if(var_name == "tks_pt"){
    return ::GetFunction(&Baby::tks_pt, "tks_pt");
  }else if(var_name == "tks_reliso"){
    return ::GetFunction(&Baby::tks_reliso, "tks_reliso");
  }else if(var_name == "tks_tm"){
    return ::GetFunction(&Baby::tks_tm, "tks_tm");
  }else if(var_name == "trig"){
    return ::GetFunction(&Baby::trig, "trig");
  }else if(var_name == "trig_lep"){
    return ::GetFunction(&Baby::trig_lep, "trig_lep");
  }else if(var_name == "trig_met"){
    return ::GetFunction(&Baby::trig_met, "trig_met");
  }else if(var_name == "trig_prescale"){
    return ::GetFunction(&Baby::trig_prescale, "trig_prescale");
  }else if(var_name == "trig_ra4"){
    return ::GetFunction(&Baby::trig_ra4, "trig_ra4");
  }else if(var_name == "trig_vvvl"){
    return ::GetFunction(&Baby::trig_vvvl, "trig_vvvl");
  }else if(var_name == "type"){
    return ::GetFunction(&Baby::type, "type");
  }else if(var_name == "w_btag"){
    return ::GetFunction(&Baby::w_btag, "w_btag");
  }else if(var_name == "w_btag40"){
    return ::GetFunction(&Baby::w_btag40, "w_btag40");
  }else if(var_name == "w_btag_loose"){
    return ::GetFunction(&Baby::w_btag_loose, "w_btag_loose");
  }else if(var_name == "w_fs_lep"){
    return ::GetFunction(&Baby::w_fs_lep, "w_fs_lep");
  }else if(var_name == "w_isr"){
    return ::GetFunction(&Baby::w_isr, "w_isr");
  }else if(var_name == "w_lep"){
    return ::GetFunction(&Baby::w_lep, "w_lep");
  }else if(var_name == "w_lumi"){
    return ::GetFunction(&Baby::w_lumi, "w_lumi");
  }else if(var_name == "w_pu"){
    return ::GetFunction(&Baby::w_pu, "w_pu");
  }else if(var_name == "w_toppt"){
    return ::GetFunction(&Baby::w_toppt, "w_toppt");
  }else if(var_name == "weight"){
    return ::GetFunction(&Baby::weight, "weight");
  }else if(var_name == "weight_rpv"){
    return ::GetFunction(&Baby::weight_rpv, "weight_rpv");
  }else{
    DBG("Function lookup failed for \"" << var_name << ".\"");
    return NamedFunc(var_name,
                     [](const Baby &){
                       return 0.;
                     });
  }
}

unique_ptr<Baby::Activator> Baby::Activate(){
  return unique_ptr<Baby::Activator>(new Baby::Activator(*this));
}

void Baby::Initialize(){
  chain_->SetMakeClass(1);
  chain_->SetBranchAddress("dphi1", &dphi1_, &b_dphi1_);
  chain_->SetBranchAddress("dphi2", &dphi2_, &b_dphi2_);
  chain_->SetBranchAddress("dphi3", &dphi3_, &b_dphi3_);
  chain_->SetBranchAddress("dphi4", &dphi4_, &b_dphi4_);
  chain_->SetBranchAddress("dphi_wlep", &dphi_wlep_, &b_dphi_wlep_);
  chain_->SetBranchAddress("eff_jetid", &eff_jetid_, &b_eff_jetid_);
  chain_->SetBranchAddress("eff_trig", &eff_trig_, &b_eff_trig_);
  chain_->SetBranchAddress("elel_eta", &elel_eta_, &b_elel_eta_);
  chain_->SetBranchAddress("elel_m", &elel_m_, &b_elel_m_);
  chain_->SetBranchAddress("elel_phi", &elel_phi_, &b_elel_phi_);
  chain_->SetBranchAddress("elel_pt", &elel_pt_, &b_elel_pt_);
  chain_->SetBranchAddress("elel_pt1", &elel_pt1_, &b_elel_pt1_);
  chain_->SetBranchAddress("elel_pt2", &elel_pt2_, &b_elel_pt2_);
  chain_->SetBranchAddress("elel_w", &elel_w_, &b_elel_w_);
  chain_->SetBranchAddress("elelv_eta", &elelv_eta_, &b_elelv_eta_);
  chain_->SetBranchAddress("elelv_m", &elelv_m_, &b_elelv_m_);
  chain_->SetBranchAddress("elelv_phi", &elelv_phi_, &b_elelv_phi_);
  chain_->SetBranchAddress("elelv_pt", &elelv_pt_, &b_elelv_pt_);
  chain_->SetBranchAddress("elelv_pt1", &elelv_pt1_, &b_elelv_pt1_);
  chain_->SetBranchAddress("elelv_pt2", &elelv_pt2_, &b_elelv_pt2_);
  chain_->SetBranchAddress("elelv_w", &elelv_w_, &b_elelv_w_);
  chain_->SetBranchAddress("elmu_eta", &elmu_eta_, &b_elmu_eta_);
  chain_->SetBranchAddress("elmu_m", &elmu_m_, &b_elmu_m_);
  chain_->SetBranchAddress("elmu_phi", &elmu_phi_, &b_elmu_phi_);
  chain_->SetBranchAddress("elmu_pt", &elmu_pt_, &b_elmu_pt_);
  chain_->SetBranchAddress("elmu_pt1", &elmu_pt1_, &b_elmu_pt1_);
  chain_->SetBranchAddress("elmu_pt2", &elmu_pt2_, &b_elmu_pt2_);
  chain_->SetBranchAddress("elmu_w", &elmu_w_, &b_elmu_w_);
  chain_->SetBranchAddress("els_charge", &els_charge_, &b_els_charge_);
  chain_->SetBranchAddress("els_d0", &els_d0_, &b_els_d0_);
  chain_->SetBranchAddress("els_deta_sctrk", &els_deta_sctrk_, &b_els_deta_sctrk_);
  chain_->SetBranchAddress("els_dphi_sctrk", &els_dphi_sctrk_, &b_els_dphi_sctrk_);
  chain_->SetBranchAddress("els_dz", &els_dz_, &b_els_dz_);
  chain_->SetBranchAddress("els_ele105", &els_ele105_, &b_els_ele105_);
  chain_->SetBranchAddress("els_ele23", &els_ele23_, &b_els_ele23_);
  chain_->SetBranchAddress("els_ele8", &els_ele8_, &b_els_ele8_);
  chain_->SetBranchAddress("els_em_e", &els_em_e_, &b_els_em_e_);
  chain_->SetBranchAddress("els_eoverp", &els_eoverp_, &b_els_eoverp_);
  chain_->SetBranchAddress("els_eta", &els_eta_, &b_els_eta_);
  chain_->SetBranchAddress("els_hovere", &els_hovere_, &b_els_hovere_);
  chain_->SetBranchAddress("els_inz", &els_inz_, &b_els_inz_);
  chain_->SetBranchAddress("els_inzv", &els_inzv_, &b_els_inzv_);
  chain_->SetBranchAddress("els_ip3d", &els_ip3d_, &b_els_ip3d_);
  chain_->SetBranchAddress("els_ispf", &els_ispf_, &b_els_ispf_);
  chain_->SetBranchAddress("els_miniso", &els_miniso_, &b_els_miniso_);
  chain_->SetBranchAddress("els_phi", &els_phi_, &b_els_phi_);
  chain_->SetBranchAddress("els_pt", &els_pt_, &b_els_pt_);
  chain_->SetBranchAddress("els_reliso", &els_reliso_, &b_els_reliso_);
  chain_->SetBranchAddress("els_sceta", &els_sceta_, &b_els_sceta_);
  chain_->SetBranchAddress("els_sig", &els_sig_, &b_els_sig_);
  chain_->SetBranchAddress("els_sigid", &els_sigid_, &b_els_sigid_);
  chain_->SetBranchAddress("els_tight", &els_tight_, &b_els_tight_);
  chain_->SetBranchAddress("els_tm", &els_tm_, &b_els_tm_);
  chain_->SetBranchAddress("els_trk_nholes", &els_trk_nholes_, &b_els_trk_nholes_);
  chain_->SetBranchAddress("els_trk_pt", &els_trk_pt_, &b_els_trk_pt_);
  chain_->SetBranchAddress("els_trk_pterr", &els_trk_pterr_, &b_els_trk_pterr_);
  chain_->SetBranchAddress("els_vvvl", &els_vvvl_, &b_els_vvvl_);
  chain_->SetBranchAddress("els_vvvl_eta", &els_vvvl_eta_, &b_els_vvvl_eta_);
  chain_->SetBranchAddress("els_vvvl_phi", &els_vvvl_phi_, &b_els_vvvl_phi_);
  chain_->SetBranchAddress("els_vvvl_pt", &els_vvvl_pt_, &b_els_vvvl_pt_);
  chain_->SetBranchAddress("event", &event_, &b_event_);
  chain_->SetBranchAddress("fjets14_eta", &fjets14_eta_, &b_fjets14_eta_);
  chain_->SetBranchAddress("fjets14_m", &fjets14_m_, &b_fjets14_m_);
  chain_->SetBranchAddress("fjets14_nconst", &fjets14_nconst_, &b_fjets14_nconst_);
  chain_->SetBranchAddress("fjets14_phi", &fjets14_phi_, &b_fjets14_phi_);
  chain_->SetBranchAddress("fjets14_pt", &fjets14_pt_, &b_fjets14_pt_);
  chain_->SetBranchAddress("fjets40_eta", &fjets40_eta_, &b_fjets40_eta_);
  chain_->SetBranchAddress("fjets40_m", &fjets40_m_, &b_fjets40_m_);
  chain_->SetBranchAddress("fjets40_nconst", &fjets40_nconst_, &b_fjets40_nconst_);
  chain_->SetBranchAddress("fjets40_phi", &fjets40_phi_, &b_fjets40_phi_);
  chain_->SetBranchAddress("fjets40_pt", &fjets40_pt_, &b_fjets40_pt_);
  chain_->SetBranchAddress("fromGS", &fromGS_, &b_fromGS_);
  chain_->SetBranchAddress("hig1_eta", &hig1_eta_, &b_hig1_eta_);
  chain_->SetBranchAddress("hig1_m", &hig1_m_, &b_hig1_m_);
  chain_->SetBranchAddress("hig1_phi", &hig1_phi_, &b_hig1_phi_);
  chain_->SetBranchAddress("hig1_pt", &hig1_pt_, &b_hig1_pt_);
  chain_->SetBranchAddress("hig2_eta", &hig2_eta_, &b_hig2_eta_);
  chain_->SetBranchAddress("hig2_m", &hig2_m_, &b_hig2_m_);
  chain_->SetBranchAddress("hig2_phi", &hig2_phi_, &b_hig2_phi_);
  chain_->SetBranchAddress("hig2_pt", &hig2_pt_, &b_hig2_pt_);
  chain_->SetBranchAddress("hig_am", &hig_am_, &b_hig_am_);
  chain_->SetBranchAddress("hig_bin", &hig_bin_, &b_hig_bin_);
  chain_->SetBranchAddress("hig_dm", &hig_dm_, &b_hig_dm_);
  chain_->SetBranchAddress("hig_dphi", &hig_dphi_, &b_hig_dphi_);
  chain_->SetBranchAddress("hig_drmax", &hig_drmax_, &b_hig_drmax_);
  chain_->SetBranchAddress("ht", &ht_, &b_ht_);
  chain_->SetBranchAddress("ht40", &ht40_, &b_ht40_);
  chain_->SetBranchAddress("ht50", &ht50_, &b_ht50_);
  chain_->SetBranchAddress("ht_clean", &ht_clean_, &b_ht_clean_);
  chain_->SetBranchAddress("ht_hlt", &ht_hlt_, &b_ht_hlt_);
  chain_->SetBranchAddress("ht_isr_me", &ht_isr_me_, &b_ht_isr_me_);
  chain_->SetBranchAddress("ht_ra2", &ht_ra2_, &b_ht_ra2_);
  chain_->SetBranchAddress("ht_tru", &ht_tru_, &b_ht_tru_);
  chain_->SetBranchAddress("htx", &htx_, &b_htx_);
  chain_->SetBranchAddress("htx40", &htx40_, &b_htx40_);
  chain_->SetBranchAddress("htx50", &htx50_, &b_htx50_);
  chain_->SetBranchAddress("isr_tru_eta", &isr_tru_eta_, &b_isr_tru_eta_);
  chain_->SetBranchAddress("isr_tru_phi", &isr_tru_phi_, &b_isr_tru_phi_);
  chain_->SetBranchAddress("isr_tru_pt", &isr_tru_pt_, &b_isr_tru_pt_);
  chain_->SetBranchAddress("jetmismeas", &jetmismeas_, &b_jetmismeas_);
  chain_->SetBranchAddress("jets_csv", &jets_csv_, &b_jets_csv_);
  chain_->SetBranchAddress("jets_eta", &jets_eta_, &b_jets_eta_);
  chain_->SetBranchAddress("jets_fjet08_index", &jets_fjet08_index_, &b_jets_fjet08_index_);
  chain_->SetBranchAddress("jets_fjet12_index", &jets_fjet12_index_, &b_jets_fjet12_index_);
  chain_->SetBranchAddress("jets_fjet14_index", &jets_fjet14_index_, &b_jets_fjet14_index_);
  chain_->SetBranchAddress("jets_fjet14_nolep_index", &jets_fjet14_nolep_index_, &b_jets_fjet14_nolep_index_);
  chain_->SetBranchAddress("jets_fjet40_index", &jets_fjet40_index_, &b_jets_fjet40_index_);
  chain_->SetBranchAddress("jets_fjet50_index", &jets_fjet50_index_, &b_jets_fjet50_index_);
  chain_->SetBranchAddress("jets_h1", &jets_h1_, &b_jets_h1_);
  chain_->SetBranchAddress("jets_h2", &jets_h2_, &b_jets_h2_);
  chain_->SetBranchAddress("jets_hflavor", &jets_hflavor_, &b_jets_hflavor_);
  chain_->SetBranchAddress("jets_isisr", &jets_isisr_, &b_jets_isisr_);
  chain_->SetBranchAddress("jets_islep", &jets_islep_, &b_jets_islep_);
  chain_->SetBranchAddress("jets_m", &jets_m_, &b_jets_m_);
  chain_->SetBranchAddress("jets_phi", &jets_phi_, &b_jets_phi_);
  chain_->SetBranchAddress("jets_pt", &jets_pt_, &b_jets_pt_);
  chain_->SetBranchAddress("jets_pt_res", &jets_pt_res_, &b_jets_pt_res_);
  chain_->SetBranchAddress("jetsys_eta", &jetsys_eta_, &b_jetsys_eta_);
  chain_->SetBranchAddress("jetsys_m", &jetsys_m_, &b_jetsys_m_);
  chain_->SetBranchAddress("jetsys_nob_eta", &jetsys_nob_eta_, &b_jetsys_nob_eta_);
  chain_->SetBranchAddress("jetsys_nob_m", &jetsys_nob_m_, &b_jetsys_nob_m_);
  chain_->SetBranchAddress("jetsys_nob_phi", &jetsys_nob_phi_, &b_jetsys_nob_phi_);
  chain_->SetBranchAddress("jetsys_nob_pt", &jetsys_nob_pt_, &b_jetsys_nob_pt_);
  chain_->SetBranchAddress("jetsys_phi", &jetsys_phi_, &b_jetsys_phi_);
  chain_->SetBranchAddress("jetsys_pt", &jetsys_pt_, &b_jetsys_pt_);
  chain_->SetBranchAddress("json12p9", &json12p9_, &b_json12p9_);
  chain_->SetBranchAddress("json2p6", &json2p6_, &b_json2p6_);
  chain_->SetBranchAddress("json4p0", &json4p0_, &b_json4p0_);
  chain_->SetBranchAddress("json7p65", &json7p65_, &b_json7p65_);
  chain_->SetBranchAddress("leps_eta", &leps_eta_, &b_leps_eta_);
  chain_->SetBranchAddress("leps_id", &leps_id_, &b_leps_id_);
  chain_->SetBranchAddress("leps_phi", &leps_phi_, &b_leps_phi_);
  chain_->SetBranchAddress("leps_pt", &leps_pt_, &b_leps_pt_);
  chain_->SetBranchAddress("low_dphi", &low_dphi_, &b_low_dphi_);
  chain_->SetBranchAddress("lumiblock", &lumiblock_, &b_lumiblock_);
  chain_->SetBranchAddress("m_tt", &m_tt_, &b_m_tt_);
  chain_->SetBranchAddress("mc_eta", &mc_eta_, &b_mc_eta_);
  chain_->SetBranchAddress("mc_id", &mc_id_, &b_mc_id_);
  chain_->SetBranchAddress("mc_mass", &mc_mass_, &b_mc_mass_);
  chain_->SetBranchAddress("mc_mom", &mc_mom_, &b_mc_mom_);
  chain_->SetBranchAddress("mc_momidx", &mc_momidx_, &b_mc_momidx_);
  chain_->SetBranchAddress("mc_phi", &mc_phi_, &b_mc_phi_);
  chain_->SetBranchAddress("mc_pt", &mc_pt_, &b_mc_pt_);
  chain_->SetBranchAddress("mc_status", &mc_status_, &b_mc_status_);
  chain_->SetBranchAddress("mct", &mct_, &b_mct_);
  chain_->SetBranchAddress("met", &met_, &b_met_);
  chain_->SetBranchAddress("met_calo", &met_calo_, &b_met_calo_);
  chain_->SetBranchAddress("met_calo_phi", &met_calo_phi_, &b_met_calo_phi_);
  chain_->SetBranchAddress("met_mini", &met_mini_, &b_met_mini_);
  chain_->SetBranchAddress("met_mini_phi", &met_mini_phi_, &b_met_mini_phi_);
  chain_->SetBranchAddress("met_nohf", &met_nohf_, &b_met_nohf_);
  chain_->SetBranchAddress("met_nohf_phi", &met_nohf_phi_, &b_met_nohf_phi_);
  chain_->SetBranchAddress("met_phi", &met_phi_, &b_met_phi_);
  chain_->SetBranchAddress("met_raw", &met_raw_, &b_met_raw_);
  chain_->SetBranchAddress("met_raw_phi", &met_raw_phi_, &b_met_raw_phi_);
  chain_->SetBranchAddress("met_rebal", &met_rebal_, &b_met_rebal_);
  chain_->SetBranchAddress("met_tru", &met_tru_, &b_met_tru_);
  chain_->SetBranchAddress("met_tru_nuw", &met_tru_nuw_, &b_met_tru_nuw_);
  chain_->SetBranchAddress("met_tru_nuw_phi", &met_tru_nuw_phi_, &b_met_tru_nuw_phi_);
  chain_->SetBranchAddress("met_tru_phi", &met_tru_phi_, &b_met_tru_phi_);
  chain_->SetBranchAddress("mgluino", &mgluino_, &b_mgluino_);
  chain_->SetBranchAddress("mht", &mht_, &b_mht_);
  chain_->SetBranchAddress("mht_clean", &mht_clean_, &b_mht_clean_);
  chain_->SetBranchAddress("mht_clean_phi", &mht_clean_phi_, &b_mht_clean_phi_);
  chain_->SetBranchAddress("mht_phi", &mht_phi_, &b_mht_phi_);
  chain_->SetBranchAddress("mj08", &mj08_, &b_mj08_);
  chain_->SetBranchAddress("mj12", &mj12_, &b_mj12_);
  chain_->SetBranchAddress("mj14", &mj14_, &b_mj14_);
  chain_->SetBranchAddress("mj14_nolep", &mj14_nolep_, &b_mj14_nolep_);
  chain_->SetBranchAddress("mj40", &mj40_, &b_mj40_);
  chain_->SetBranchAddress("mj50", &mj50_, &b_mj50_);
  chain_->SetBranchAddress("mlsp", &mlsp_, &b_mlsp_);
  chain_->SetBranchAddress("mm", &mm_, &b_mm_);
  chain_->SetBranchAddress("mm_el_miniso", &mm_el_miniso_, &b_mm_el_miniso_);
  chain_->SetBranchAddress("mm_el_pt", &mm_el_pt_, &b_mm_el_pt_);
  chain_->SetBranchAddress("mm_ht", &mm_ht_, &b_mm_ht_);
  chain_->SetBranchAddress("mm_jet_eta", &mm_jet_eta_, &b_mm_jet_eta_);
  chain_->SetBranchAddress("mm_jet_m", &mm_jet_m_, &b_mm_jet_m_);
  chain_->SetBranchAddress("mm_jet_phi", &mm_jet_phi_, &b_mm_jet_phi_);
  chain_->SetBranchAddress("mm_jet_pt", &mm_jet_pt_, &b_mm_jet_pt_);
  chain_->SetBranchAddress("mm_lep_pt", &mm_lep_pt_, &b_mm_lep_pt_);
  chain_->SetBranchAddress("mm_met", &mm_met_, &b_mm_met_);
  chain_->SetBranchAddress("mm_met_phi", &mm_met_phi_, &b_mm_met_phi_);
  chain_->SetBranchAddress("mm_mj14_lep", &mm_mj14_lep_, &b_mm_mj14_lep_);
  chain_->SetBranchAddress("mm_mj14_nolep", &mm_mj14_nolep_, &b_mm_mj14_nolep_);
  chain_->SetBranchAddress("mm_mt", &mm_mt_, &b_mm_mt_);
  chain_->SetBranchAddress("mm_mu_miniso", &mm_mu_miniso_, &b_mm_mu_miniso_);
  chain_->SetBranchAddress("mm_mu_pt", &mm_mu_pt_, &b_mm_mu_pt_);
  chain_->SetBranchAddress("mm_nbm", &mm_nbm_, &b_mm_nbm_);
  chain_->SetBranchAddress("mm_nels", &mm_nels_, &b_mm_nels_);
  chain_->SetBranchAddress("mm_njets", &mm_njets_, &b_mm_njets_);
  chain_->SetBranchAddress("mm_nleps", &mm_nleps_, &b_mm_nleps_);
  chain_->SetBranchAddress("mm_nmus", &mm_nmus_, &b_mm_nmus_);
  chain_->SetBranchAddress("mt", &mt_, &b_mt_);
  chain_->SetBranchAddress("mt2", &mt2_, &b_mt2_);
  chain_->SetBranchAddress("mt2_0mass", &mt2_0mass_, &b_mt2_0mass_);
  chain_->SetBranchAddress("mt_nohf", &mt_nohf_, &b_mt_nohf_);
  chain_->SetBranchAddress("mt_rebal", &mt_rebal_, &b_mt_rebal_);
  chain_->SetBranchAddress("mt_tru", &mt_tru_, &b_mt_tru_);
  chain_->SetBranchAddress("mt_tru_nuw", &mt_tru_nuw_, &b_mt_tru_nuw_);
  chain_->SetBranchAddress("mumu_eta", &mumu_eta_, &b_mumu_eta_);
  chain_->SetBranchAddress("mumu_m", &mumu_m_, &b_mumu_m_);
  chain_->SetBranchAddress("mumu_phi", &mumu_phi_, &b_mumu_phi_);
  chain_->SetBranchAddress("mumu_pt", &mumu_pt_, &b_mumu_pt_);
  chain_->SetBranchAddress("mumu_pt1", &mumu_pt1_, &b_mumu_pt1_);
  chain_->SetBranchAddress("mumu_pt2", &mumu_pt2_, &b_mumu_pt2_);
  chain_->SetBranchAddress("mumu_w", &mumu_w_, &b_mumu_w_);
  chain_->SetBranchAddress("mumuv_eta", &mumuv_eta_, &b_mumuv_eta_);
  chain_->SetBranchAddress("mumuv_m", &mumuv_m_, &b_mumuv_m_);
  chain_->SetBranchAddress("mumuv_phi", &mumuv_phi_, &b_mumuv_phi_);
  chain_->SetBranchAddress("mumuv_pt", &mumuv_pt_, &b_mumuv_pt_);
  chain_->SetBranchAddress("mumuv_pt1", &mumuv_pt1_, &b_mumuv_pt1_);
  chain_->SetBranchAddress("mumuv_pt2", &mumuv_pt2_, &b_mumuv_pt2_);
  chain_->SetBranchAddress("mumuv_w", &mumuv_w_, &b_mumuv_w_);
  chain_->SetBranchAddress("mus_charge", &mus_charge_, &b_mus_charge_);
  chain_->SetBranchAddress("mus_d0", &mus_d0_, &b_mus_d0_);
  chain_->SetBranchAddress("mus_dz", &mus_dz_, &b_mus_dz_);
  chain_->SetBranchAddress("mus_em_e", &mus_em_e_, &b_mus_em_e_);
  chain_->SetBranchAddress("mus_eta", &mus_eta_, &b_mus_eta_);
  chain_->SetBranchAddress("mus_had_e", &mus_had_e_, &b_mus_had_e_);
  chain_->SetBranchAddress("mus_inz", &mus_inz_, &b_mus_inz_);
  chain_->SetBranchAddress("mus_inzv", &mus_inzv_, &b_mus_inzv_);
  chain_->SetBranchAddress("mus_isomu18", &mus_isomu18_, &b_mus_isomu18_);
  chain_->SetBranchAddress("mus_miniso", &mus_miniso_, &b_mus_miniso_);
  chain_->SetBranchAddress("mus_mu50", &mus_mu50_, &b_mus_mu50_);
  chain_->SetBranchAddress("mus_mu8", &mus_mu8_, &b_mus_mu8_);
  chain_->SetBranchAddress("mus_phi", &mus_phi_, &b_mus_phi_);
  chain_->SetBranchAddress("mus_pt", &mus_pt_, &b_mus_pt_);
  chain_->SetBranchAddress("mus_pterr", &mus_pterr_, &b_mus_pterr_);
  chain_->SetBranchAddress("mus_reliso", &mus_reliso_, &b_mus_reliso_);
  chain_->SetBranchAddress("mus_sig", &mus_sig_, &b_mus_sig_);
  chain_->SetBranchAddress("mus_sigid", &mus_sigid_, &b_mus_sigid_);
  chain_->SetBranchAddress("mus_tight", &mus_tight_, &b_mus_tight_);
  chain_->SetBranchAddress("mus_tm", &mus_tm_, &b_mus_tm_);
  chain_->SetBranchAddress("mus_trk_algo", &mus_trk_algo_, &b_mus_trk_algo_);
  chain_->SetBranchAddress("mus_trk_nholes_in", &mus_trk_nholes_in_, &b_mus_trk_nholes_in_);
  chain_->SetBranchAddress("mus_trk_nholes_out", &mus_trk_nholes_out_, &b_mus_trk_nholes_out_);
  chain_->SetBranchAddress("mus_trk_quality", &mus_trk_quality_, &b_mus_trk_quality_);
  chain_->SetBranchAddress("mus_vvvl", &mus_vvvl_, &b_mus_vvvl_);
  chain_->SetBranchAddress("mus_vvvl_eta", &mus_vvvl_eta_, &b_mus_vvvl_eta_);
  chain_->SetBranchAddress("mus_vvvl_phi", &mus_vvvl_phi_, &b_mus_vvvl_phi_);
  chain_->SetBranchAddress("mus_vvvl_pt", &mus_vvvl_pt_, &b_mus_vvvl_pt_);
  chain_->SetBranchAddress("nbl", &nbl_, &b_nbl_);
  chain_->SetBranchAddress("nbm", &nbm_, &b_nbm_);
  chain_->SetBranchAddress("nbm20", &nbm20_, &b_nbm20_);
  chain_->SetBranchAddress("nbm40", &nbm40_, &b_nbm40_);
  chain_->SetBranchAddress("nbm50", &nbm50_, &b_nbm50_);
  chain_->SetBranchAddress("nbm_ra2", &nbm_ra2_, &b_nbm_ra2_);
  chain_->SetBranchAddress("nbt", &nbt_, &b_nbt_);
  chain_->SetBranchAddress("nels", &nels_, &b_nels_);
  chain_->SetBranchAddress("nels_ele23", &nels_ele23_, &b_nels_ele23_);
  chain_->SetBranchAddress("nels_vvvl", &nels_vvvl_, &b_nels_vvvl_);
  chain_->SetBranchAddress("nfjets14", &nfjets14_, &b_nfjets14_);
  chain_->SetBranchAddress("nfjets40", &nfjets40_, &b_nfjets40_);
  chain_->SetBranchAddress("nisr", &nisr_, &b_nisr_);
  chain_->SetBranchAddress("nisr_me", &nisr_me_, &b_nisr_me_);
  chain_->SetBranchAddress("njets", &njets_, &b_njets_);
  chain_->SetBranchAddress("njets20", &njets20_, &b_njets20_);
  chain_->SetBranchAddress("njets40", &njets40_, &b_njets40_);
  chain_->SetBranchAddress("njets50", &njets50_, &b_njets50_);
  chain_->SetBranchAddress("njets_clean", &njets_clean_, &b_njets_clean_);
  chain_->SetBranchAddress("njets_ra2", &njets_ra2_, &b_njets_ra2_);
  chain_->SetBranchAddress("nleps", &nleps_, &b_nleps_);
  chain_->SetBranchAddress("nleps_tm", &nleps_tm_, &b_nleps_tm_);
  chain_->SetBranchAddress("nmus", &nmus_, &b_nmus_);
  chain_->SetBranchAddress("nmus_isomu18", &nmus_isomu18_, &b_nmus_isomu18_);
  chain_->SetBranchAddress("nmus_vvvl", &nmus_vvvl_, &b_nmus_vvvl_);
  chain_->SetBranchAddress("nonblind", &nonblind_, &b_nonblind_);
  chain_->SetBranchAddress("nph", &nph_, &b_nph_);
  chain_->SetBranchAddress("npv", &npv_, &b_npv_);
  chain_->SetBranchAddress("ntks", &ntks_, &b_ntks_);
  chain_->SetBranchAddress("ntruels", &ntruels_, &b_ntruels_);
  chain_->SetBranchAddress("ntruleps", &ntruleps_, &b_ntruleps_);
  chain_->SetBranchAddress("ntrumus", &ntrumus_, &b_ntrumus_);
  chain_->SetBranchAddress("ntrupv", &ntrupv_, &b_ntrupv_);
  chain_->SetBranchAddress("ntrupv_mean", &ntrupv_mean_, &b_ntrupv_mean_);
  chain_->SetBranchAddress("ntrutaush", &ntrutaush_, &b_ntrutaush_);
  chain_->SetBranchAddress("ntrutausl", &ntrutausl_, &b_ntrutausl_);
  chain_->SetBranchAddress("nvels", &nvels_, &b_nvels_);
  chain_->SetBranchAddress("nveto", &nveto_, &b_nveto_);
  chain_->SetBranchAddress("nvleps", &nvleps_, &b_nvleps_);
  chain_->SetBranchAddress("nvmus", &nvmus_, &b_nvmus_);
  chain_->SetBranchAddress("onel_ele105", &onel_ele105_, &b_onel_ele105_);
  chain_->SetBranchAddress("onel_ele23", &onel_ele23_, &b_onel_ele23_);
  chain_->SetBranchAddress("onel_ele8", &onel_ele8_, &b_onel_ele8_);
  chain_->SetBranchAddress("onel_vvvl", &onel_vvvl_, &b_onel_vvvl_);
  chain_->SetBranchAddress("onht", &onht_, &b_onht_);
  chain_->SetBranchAddress("onmet", &onmet_, &b_onmet_);
  chain_->SetBranchAddress("onmu_isomu18", &onmu_isomu18_, &b_onmu_isomu18_);
  chain_->SetBranchAddress("onmu_mu50", &onmu_mu50_, &b_onmu_mu50_);
  chain_->SetBranchAddress("onmu_mu8", &onmu_mu8_, &b_onmu_mu8_);
  chain_->SetBranchAddress("onmu_vvvl", &onmu_vvvl_, &b_onmu_vvvl_);
  chain_->SetBranchAddress("onph_ph90", &onph_ph90_, &b_onph_ph90_);
  chain_->SetBranchAddress("pass", &pass_, &b_pass_);
  chain_->SetBranchAddress("pass20", &pass20_, &b_pass20_);
  chain_->SetBranchAddress("pass40", &pass40_, &b_pass40_);
  chain_->SetBranchAddress("pass50", &pass50_, &b_pass50_);
  chain_->SetBranchAddress("pass_cschalo", &pass_cschalo_, &b_pass_cschalo_);
  chain_->SetBranchAddress("pass_ecaldeadcell", &pass_ecaldeadcell_, &b_pass_ecaldeadcell_);
  chain_->SetBranchAddress("pass_eebadsc", &pass_eebadsc_, &b_pass_eebadsc_);
  chain_->SetBranchAddress("pass_goodv", &pass_goodv_, &b_pass_goodv_);
  chain_->SetBranchAddress("pass_hbhe", &pass_hbhe_, &b_pass_hbhe_);
  chain_->SetBranchAddress("pass_hbheiso", &pass_hbheiso_, &b_pass_hbheiso_);
  chain_->SetBranchAddress("pass_jets", &pass_jets_, &b_pass_jets_);
  chain_->SetBranchAddress("pass_jets20", &pass_jets20_, &b_pass_jets20_);
  chain_->SetBranchAddress("pass_jets40", &pass_jets40_, &b_pass_jets40_);
  chain_->SetBranchAddress("pass_jets50", &pass_jets50_, &b_pass_jets50_);
  chain_->SetBranchAddress("pass_jets_nohf", &pass_jets_nohf_, &b_pass_jets_nohf_);
  chain_->SetBranchAddress("pass_jets_ra2", &pass_jets_ra2_, &b_pass_jets_ra2_);
  chain_->SetBranchAddress("pass_jets_tight", &pass_jets_tight_, &b_pass_jets_tight_);
  chain_->SetBranchAddress("pass_jets_tight_ra2", &pass_jets_tight_ra2_, &b_pass_jets_tight_ra2_);
  chain_->SetBranchAddress("pass_nohf", &pass_nohf_, &b_pass_nohf_);
  chain_->SetBranchAddress("pass_ra2", &pass_ra2_, &b_pass_ra2_);
  chain_->SetBranchAddress("pass_ra2_badmu", &pass_ra2_badmu_, &b_pass_ra2_badmu_);
  chain_->SetBranchAddress("ph_eta", &ph_eta_, &b_ph_eta_);
  chain_->SetBranchAddress("ph_ph90", &ph_ph90_, &b_ph_ph90_);
  chain_->SetBranchAddress("ph_phi", &ph_phi_, &b_ph_phi_);
  chain_->SetBranchAddress("ph_pt", &ph_pt_, &b_ph_pt_);
  chain_->SetBranchAddress("ph_tm", &ph_tm_, &b_ph_tm_);
  chain_->SetBranchAddress("run", &run_, &b_run_);
  chain_->SetBranchAddress("st", &st_, &b_st_);
  chain_->SetBranchAddress("st40", &st40_, &b_st40_);
  chain_->SetBranchAddress("st50", &st50_, &b_st50_);
  chain_->SetBranchAddress("stitch", &stitch_, &b_stitch_);
  chain_->SetBranchAddress("sys_bctag", &sys_bctag_, &b_sys_bctag_);
  chain_->SetBranchAddress("sys_bctag40", &sys_bctag40_, &b_sys_bctag40_);
  chain_->SetBranchAddress("sys_bctag_loose", &sys_bctag_loose_, &b_sys_bctag_loose_);
  chain_->SetBranchAddress("sys_fs_bctag", &sys_fs_bctag_, &b_sys_fs_bctag_);
  chain_->SetBranchAddress("sys_fs_bctag40", &sys_fs_bctag40_, &b_sys_fs_bctag40_);
  chain_->SetBranchAddress("sys_fs_lep", &sys_fs_lep_, &b_sys_fs_lep_);
  chain_->SetBranchAddress("sys_fs_udsgtag", &sys_fs_udsgtag_, &b_sys_fs_udsgtag_);
  chain_->SetBranchAddress("sys_fs_udsgtag40", &sys_fs_udsgtag40_, &b_sys_fs_udsgtag40_);
  chain_->SetBranchAddress("sys_ht", &sys_ht_, &b_sys_ht_);
  chain_->SetBranchAddress("sys_ht40", &sys_ht40_, &b_sys_ht40_);
  chain_->SetBranchAddress("sys_isr", &sys_isr_, &b_sys_isr_);
  chain_->SetBranchAddress("sys_lep", &sys_lep_, &b_sys_lep_);
  chain_->SetBranchAddress("sys_met", &sys_met_, &b_sys_met_);
  chain_->SetBranchAddress("sys_mj14", &sys_mj14_, &b_sys_mj14_);
  chain_->SetBranchAddress("sys_mj14_nolep", &sys_mj14_nolep_, &b_sys_mj14_nolep_);
  chain_->SetBranchAddress("sys_mj40", &sys_mj40_, &b_sys_mj40_);
  chain_->SetBranchAddress("sys_mt", &sys_mt_, &b_sys_mt_);
  chain_->SetBranchAddress("sys_muf", &sys_muf_, &b_sys_muf_);
  chain_->SetBranchAddress("sys_mur", &sys_mur_, &b_sys_mur_);
  chain_->SetBranchAddress("sys_murf", &sys_murf_, &b_sys_murf_);
  chain_->SetBranchAddress("sys_nbm", &sys_nbm_, &b_sys_nbm_);
  chain_->SetBranchAddress("sys_nbm40", &sys_nbm40_, &b_sys_nbm40_);
  chain_->SetBranchAddress("sys_njets", &sys_njets_, &b_sys_njets_);
  chain_->SetBranchAddress("sys_njets40", &sys_njets40_, &b_sys_njets40_);
  chain_->SetBranchAddress("sys_pass", &sys_pass_, &b_sys_pass_);
  chain_->SetBranchAddress("sys_pass40", &sys_pass40_, &b_sys_pass40_);
  chain_->SetBranchAddress("sys_pu", &sys_pu_, &b_sys_pu_);
  chain_->SetBranchAddress("sys_st", &sys_st_, &b_sys_st_);
  chain_->SetBranchAddress("sys_st40", &sys_st40_, &b_sys_st40_);
  chain_->SetBranchAddress("sys_trig", &sys_trig_, &b_sys_trig_);
  chain_->SetBranchAddress("sys_udsgtag", &sys_udsgtag_, &b_sys_udsgtag_);
  chain_->SetBranchAddress("sys_udsgtag40", &sys_udsgtag40_, &b_sys_udsgtag40_);
  chain_->SetBranchAddress("sys_udsgtag_loose", &sys_udsgtag_loose_, &b_sys_udsgtag_loose_);
  chain_->SetBranchAddress("tks_d0", &tks_d0_, &b_tks_d0_);
  chain_->SetBranchAddress("tks_dz", &tks_dz_, &b_tks_dz_);
  chain_->SetBranchAddress("tks_eta", &tks_eta_, &b_tks_eta_);
  chain_->SetBranchAddress("tks_miniso", &tks_miniso_, &b_tks_miniso_);
  chain_->SetBranchAddress("tks_mt", &tks_mt_, &b_tks_mt_);
  chain_->SetBranchAddress("tks_mt2", &tks_mt2_, &b_tks_mt2_);
  chain_->SetBranchAddress("tks_pdg", &tks_pdg_, &b_tks_pdg_);
  chain_->SetBranchAddress("tks_phi", &tks_phi_, &b_tks_phi_);
  chain_->SetBranchAddress("tks_pt", &tks_pt_, &b_tks_pt_);
  chain_->SetBranchAddress("tks_reliso", &tks_reliso_, &b_tks_reliso_);
  chain_->SetBranchAddress("tks_tm", &tks_tm_, &b_tks_tm_);
  chain_->SetBranchAddress("trig", &trig_, &b_trig_);
  chain_->SetBranchAddress("trig_lep", &trig_lep_, &b_trig_lep_);
  chain_->SetBranchAddress("trig_met", &trig_met_, &b_trig_met_);
  chain_->SetBranchAddress("trig_prescale", &trig_prescale_, &b_trig_prescale_);
  chain_->SetBranchAddress("trig_ra4", &trig_ra4_, &b_trig_ra4_);
  chain_->SetBranchAddress("trig_vvvl", &trig_vvvl_, &b_trig_vvvl_);
  chain_->SetBranchAddress("type", &type_, &b_type_);
  chain_->SetBranchAddress("w_btag", &w_btag_, &b_w_btag_);
  chain_->SetBranchAddress("w_btag40", &w_btag40_, &b_w_btag40_);
  chain_->SetBranchAddress("w_btag_loose", &w_btag_loose_, &b_w_btag_loose_);
  chain_->SetBranchAddress("w_fs_lep", &w_fs_lep_, &b_w_fs_lep_);
  chain_->SetBranchAddress("w_isr", &w_isr_, &b_w_isr_);
  chain_->SetBranchAddress("w_lep", &w_lep_, &b_w_lep_);
  chain_->SetBranchAddress("w_lumi", &w_lumi_, &b_w_lumi_);
  chain_->SetBranchAddress("w_pu", &w_pu_, &b_w_pu_);
  chain_->SetBranchAddress("w_toppt", &w_toppt_, &b_w_toppt_);
  chain_->SetBranchAddress("weight", &weight_, &b_weight_);
  chain_->SetBranchAddress("weight_rpv", &weight_rpv_, &b_weight_rpv_);
}

void Baby::ActivateChain(){
  if(chain_) ERROR("Chain has already been initialized");
  lock_guard<mutex> lock(Multithreading::root_mutex);
  chain_ = unique_ptr<TChain>(new TChain("tree"));
  for(const auto &file: file_names_){
    chain_->Add(file.c_str());
  }
  Initialize();
}

void Baby::DeactivateChain(){
  lock_guard<mutex> lock(Multithreading::root_mutex);
  chain_.reset();
}

float const & Baby::dphi1() const{
  if(!c_dphi1_ && b_dphi1_){
    b_dphi1_->GetEntry(entry_);
    c_dphi1_ = true;
  }
  return dphi1_;
}

float const & Baby::dphi2() const{
  if(!c_dphi2_ && b_dphi2_){
    b_dphi2_->GetEntry(entry_);
    c_dphi2_ = true;
  }
  return dphi2_;
}

float const & Baby::dphi3() const{
  if(!c_dphi3_ && b_dphi3_){
    b_dphi3_->GetEntry(entry_);
    c_dphi3_ = true;
  }
  return dphi3_;
}

float const & Baby::dphi4() const{
  if(!c_dphi4_ && b_dphi4_){
    b_dphi4_->GetEntry(entry_);
    c_dphi4_ = true;
  }
  return dphi4_;
}

float const & Baby::dphi_wlep() const{
  if(!c_dphi_wlep_ && b_dphi_wlep_){
    b_dphi_wlep_->GetEntry(entry_);
    c_dphi_wlep_ = true;
  }
  return dphi_wlep_;
}

float const & Baby::eff_jetid() const{
  if(!c_eff_jetid_ && b_eff_jetid_){
    b_eff_jetid_->GetEntry(entry_);
    c_eff_jetid_ = true;
  }
  return eff_jetid_;
}

float const & Baby::eff_trig() const{
  if(!c_eff_trig_ && b_eff_trig_){
    b_eff_trig_->GetEntry(entry_);
    c_eff_trig_ = true;
  }
  return eff_trig_;
}

float const & Baby::elel_eta() const{
  if(!c_elel_eta_ && b_elel_eta_){
    b_elel_eta_->GetEntry(entry_);
    c_elel_eta_ = true;
  }
  return elel_eta_;
}

float const & Baby::elel_m() const{
  if(!c_elel_m_ && b_elel_m_){
    b_elel_m_->GetEntry(entry_);
    c_elel_m_ = true;
  }
  return elel_m_;
}

float const & Baby::elel_phi() const{
  if(!c_elel_phi_ && b_elel_phi_){
    b_elel_phi_->GetEntry(entry_);
    c_elel_phi_ = true;
  }
  return elel_phi_;
}

float const & Baby::elel_pt() const{
  if(!c_elel_pt_ && b_elel_pt_){
    b_elel_pt_->GetEntry(entry_);
    c_elel_pt_ = true;
  }
  return elel_pt_;
}

float const & Baby::elel_pt1() const{
  if(!c_elel_pt1_ && b_elel_pt1_){
    b_elel_pt1_->GetEntry(entry_);
    c_elel_pt1_ = true;
  }
  return elel_pt1_;
}

float const & Baby::elel_pt2() const{
  if(!c_elel_pt2_ && b_elel_pt2_){
    b_elel_pt2_->GetEntry(entry_);
    c_elel_pt2_ = true;
  }
  return elel_pt2_;
}

float const & Baby::elel_w() const{
  if(!c_elel_w_ && b_elel_w_){
    b_elel_w_->GetEntry(entry_);
    c_elel_w_ = true;
  }
  return elel_w_;
}

float const & Baby::elelv_eta() const{
  if(!c_elelv_eta_ && b_elelv_eta_){
    b_elelv_eta_->GetEntry(entry_);
    c_elelv_eta_ = true;
  }
  return elelv_eta_;
}

float const & Baby::elelv_m() const{
  if(!c_elelv_m_ && b_elelv_m_){
    b_elelv_m_->GetEntry(entry_);
    c_elelv_m_ = true;
  }
  return elelv_m_;
}

float const & Baby::elelv_phi() const{
  if(!c_elelv_phi_ && b_elelv_phi_){
    b_elelv_phi_->GetEntry(entry_);
    c_elelv_phi_ = true;
  }
  return elelv_phi_;
}

float const & Baby::elelv_pt() const{
  if(!c_elelv_pt_ && b_elelv_pt_){
    b_elelv_pt_->GetEntry(entry_);
    c_elelv_pt_ = true;
  }
  return elelv_pt_;
}

float const & Baby::elelv_pt1() const{
  if(!c_elelv_pt1_ && b_elelv_pt1_){
    b_elelv_pt1_->GetEntry(entry_);
    c_elelv_pt1_ = true;
  }
  return elelv_pt1_;
}

float const & Baby::elelv_pt2() const{
  if(!c_elelv_pt2_ && b_elelv_pt2_){
    b_elelv_pt2_->GetEntry(entry_);
    c_elelv_pt2_ = true;
  }
  return elelv_pt2_;
}

float const & Baby::elelv_w() const{
  if(!c_elelv_w_ && b_elelv_w_){
    b_elelv_w_->GetEntry(entry_);
    c_elelv_w_ = true;
  }
  return elelv_w_;
}

float const & Baby::elmu_eta() const{
  if(!c_elmu_eta_ && b_elmu_eta_){
    b_elmu_eta_->GetEntry(entry_);
    c_elmu_eta_ = true;
  }
  return elmu_eta_;
}

float const & Baby::elmu_m() const{
  if(!c_elmu_m_ && b_elmu_m_){
    b_elmu_m_->GetEntry(entry_);
    c_elmu_m_ = true;
  }
  return elmu_m_;
}

float const & Baby::elmu_phi() const{
  if(!c_elmu_phi_ && b_elmu_phi_){
    b_elmu_phi_->GetEntry(entry_);
    c_elmu_phi_ = true;
  }
  return elmu_phi_;
}

float const & Baby::elmu_pt() const{
  if(!c_elmu_pt_ && b_elmu_pt_){
    b_elmu_pt_->GetEntry(entry_);
    c_elmu_pt_ = true;
  }
  return elmu_pt_;
}

float const & Baby::elmu_pt1() const{
  if(!c_elmu_pt1_ && b_elmu_pt1_){
    b_elmu_pt1_->GetEntry(entry_);
    c_elmu_pt1_ = true;
  }
  return elmu_pt1_;
}

float const & Baby::elmu_pt2() const{
  if(!c_elmu_pt2_ && b_elmu_pt2_){
    b_elmu_pt2_->GetEntry(entry_);
    c_elmu_pt2_ = true;
  }
  return elmu_pt2_;
}

float const & Baby::elmu_w() const{
  if(!c_elmu_w_ && b_elmu_w_){
    b_elmu_w_->GetEntry(entry_);
    c_elmu_w_ = true;
  }
  return elmu_w_;
}

std::vector<int>* const & Baby::els_charge() const{
  if(!c_els_charge_ && b_els_charge_){
    b_els_charge_->GetEntry(entry_);
    c_els_charge_ = true;
  }
  return els_charge_;
}

std::vector<float>* const & Baby::els_d0() const{
  if(!c_els_d0_ && b_els_d0_){
    b_els_d0_->GetEntry(entry_);
    c_els_d0_ = true;
  }
  return els_d0_;
}

std::vector<float>* const & Baby::els_deta_sctrk() const{
  if(!c_els_deta_sctrk_ && b_els_deta_sctrk_){
    b_els_deta_sctrk_->GetEntry(entry_);
    c_els_deta_sctrk_ = true;
  }
  return els_deta_sctrk_;
}

std::vector<float>* const & Baby::els_dphi_sctrk() const{
  if(!c_els_dphi_sctrk_ && b_els_dphi_sctrk_){
    b_els_dphi_sctrk_->GetEntry(entry_);
    c_els_dphi_sctrk_ = true;
  }
  return els_dphi_sctrk_;
}

std::vector<float>* const & Baby::els_dz() const{
  if(!c_els_dz_ && b_els_dz_){
    b_els_dz_->GetEntry(entry_);
    c_els_dz_ = true;
  }
  return els_dz_;
}

std::vector<bool>* const & Baby::els_ele105() const{
  if(!c_els_ele105_ && b_els_ele105_){
    b_els_ele105_->GetEntry(entry_);
    c_els_ele105_ = true;
  }
  return els_ele105_;
}

std::vector<bool>* const & Baby::els_ele23() const{
  if(!c_els_ele23_ && b_els_ele23_){
    b_els_ele23_->GetEntry(entry_);
    c_els_ele23_ = true;
  }
  return els_ele23_;
}

std::vector<bool>* const & Baby::els_ele8() const{
  if(!c_els_ele8_ && b_els_ele8_){
    b_els_ele8_->GetEntry(entry_);
    c_els_ele8_ = true;
  }
  return els_ele8_;
}

std::vector<float>* const & Baby::els_em_e() const{
  if(!c_els_em_e_ && b_els_em_e_){
    b_els_em_e_->GetEntry(entry_);
    c_els_em_e_ = true;
  }
  return els_em_e_;
}

std::vector<float>* const & Baby::els_eoverp() const{
  if(!c_els_eoverp_ && b_els_eoverp_){
    b_els_eoverp_->GetEntry(entry_);
    c_els_eoverp_ = true;
  }
  return els_eoverp_;
}

std::vector<float>* const & Baby::els_eta() const{
  if(!c_els_eta_ && b_els_eta_){
    b_els_eta_->GetEntry(entry_);
    c_els_eta_ = true;
  }
  return els_eta_;
}

std::vector<float>* const & Baby::els_hovere() const{
  if(!c_els_hovere_ && b_els_hovere_){
    b_els_hovere_->GetEntry(entry_);
    c_els_hovere_ = true;
  }
  return els_hovere_;
}

std::vector<bool>* const & Baby::els_inz() const{
  if(!c_els_inz_ && b_els_inz_){
    b_els_inz_->GetEntry(entry_);
    c_els_inz_ = true;
  }
  return els_inz_;
}

std::vector<bool>* const & Baby::els_inzv() const{
  if(!c_els_inzv_ && b_els_inzv_){
    b_els_inzv_->GetEntry(entry_);
    c_els_inzv_ = true;
  }
  return els_inzv_;
}

std::vector<float>* const & Baby::els_ip3d() const{
  if(!c_els_ip3d_ && b_els_ip3d_){
    b_els_ip3d_->GetEntry(entry_);
    c_els_ip3d_ = true;
  }
  return els_ip3d_;
}

std::vector<bool>* const & Baby::els_ispf() const{
  if(!c_els_ispf_ && b_els_ispf_){
    b_els_ispf_->GetEntry(entry_);
    c_els_ispf_ = true;
  }
  return els_ispf_;
}

std::vector<float>* const & Baby::els_miniso() const{
  if(!c_els_miniso_ && b_els_miniso_){
    b_els_miniso_->GetEntry(entry_);
    c_els_miniso_ = true;
  }
  return els_miniso_;
}

std::vector<float>* const & Baby::els_phi() const{
  if(!c_els_phi_ && b_els_phi_){
    b_els_phi_->GetEntry(entry_);
    c_els_phi_ = true;
  }
  return els_phi_;
}

std::vector<float>* const & Baby::els_pt() const{
  if(!c_els_pt_ && b_els_pt_){
    b_els_pt_->GetEntry(entry_);
    c_els_pt_ = true;
  }
  return els_pt_;
}

std::vector<float>* const & Baby::els_reliso() const{
  if(!c_els_reliso_ && b_els_reliso_){
    b_els_reliso_->GetEntry(entry_);
    c_els_reliso_ = true;
  }
  return els_reliso_;
}

std::vector<float>* const & Baby::els_sceta() const{
  if(!c_els_sceta_ && b_els_sceta_){
    b_els_sceta_->GetEntry(entry_);
    c_els_sceta_ = true;
  }
  return els_sceta_;
}

std::vector<bool>* const & Baby::els_sig() const{
  if(!c_els_sig_ && b_els_sig_){
    b_els_sig_->GetEntry(entry_);
    c_els_sig_ = true;
  }
  return els_sig_;
}

std::vector<bool>* const & Baby::els_sigid() const{
  if(!c_els_sigid_ && b_els_sigid_){
    b_els_sigid_->GetEntry(entry_);
    c_els_sigid_ = true;
  }
  return els_sigid_;
}

std::vector<bool>* const & Baby::els_tight() const{
  if(!c_els_tight_ && b_els_tight_){
    b_els_tight_->GetEntry(entry_);
    c_els_tight_ = true;
  }
  return els_tight_;
}

std::vector<bool>* const & Baby::els_tm() const{
  if(!c_els_tm_ && b_els_tm_){
    b_els_tm_->GetEntry(entry_);
    c_els_tm_ = true;
  }
  return els_tm_;
}

std::vector<int>* const & Baby::els_trk_nholes() const{
  if(!c_els_trk_nholes_ && b_els_trk_nholes_){
    b_els_trk_nholes_->GetEntry(entry_);
    c_els_trk_nholes_ = true;
  }
  return els_trk_nholes_;
}

std::vector<float>* const & Baby::els_trk_pt() const{
  if(!c_els_trk_pt_ && b_els_trk_pt_){
    b_els_trk_pt_->GetEntry(entry_);
    c_els_trk_pt_ = true;
  }
  return els_trk_pt_;
}

std::vector<float>* const & Baby::els_trk_pterr() const{
  if(!c_els_trk_pterr_ && b_els_trk_pterr_){
    b_els_trk_pterr_->GetEntry(entry_);
    c_els_trk_pterr_ = true;
  }
  return els_trk_pterr_;
}

std::vector<bool>* const & Baby::els_vvvl() const{
  if(!c_els_vvvl_ && b_els_vvvl_){
    b_els_vvvl_->GetEntry(entry_);
    c_els_vvvl_ = true;
  }
  return els_vvvl_;
}

std::vector<float>* const & Baby::els_vvvl_eta() const{
  if(!c_els_vvvl_eta_ && b_els_vvvl_eta_){
    b_els_vvvl_eta_->GetEntry(entry_);
    c_els_vvvl_eta_ = true;
  }
  return els_vvvl_eta_;
}

std::vector<float>* const & Baby::els_vvvl_phi() const{
  if(!c_els_vvvl_phi_ && b_els_vvvl_phi_){
    b_els_vvvl_phi_->GetEntry(entry_);
    c_els_vvvl_phi_ = true;
  }
  return els_vvvl_phi_;
}

std::vector<float>* const & Baby::els_vvvl_pt() const{
  if(!c_els_vvvl_pt_ && b_els_vvvl_pt_){
    b_els_vvvl_pt_->GetEntry(entry_);
    c_els_vvvl_pt_ = true;
  }
  return els_vvvl_pt_;
}

Long64_t const & Baby::event() const{
  if(!c_event_ && b_event_){
    b_event_->GetEntry(entry_);
    c_event_ = true;
  }
  return event_;
}

std::vector<float>* const & Baby::fjets14_eta() const{
  if(!c_fjets14_eta_ && b_fjets14_eta_){
    b_fjets14_eta_->GetEntry(entry_);
    c_fjets14_eta_ = true;
  }
  return fjets14_eta_;
}

std::vector<float>* const & Baby::fjets14_m() const{
  if(!c_fjets14_m_ && b_fjets14_m_){
    b_fjets14_m_->GetEntry(entry_);
    c_fjets14_m_ = true;
  }
  return fjets14_m_;
}

std::vector<int>* const & Baby::fjets14_nconst() const{
  if(!c_fjets14_nconst_ && b_fjets14_nconst_){
    b_fjets14_nconst_->GetEntry(entry_);
    c_fjets14_nconst_ = true;
  }
  return fjets14_nconst_;
}

std::vector<float>* const & Baby::fjets14_phi() const{
  if(!c_fjets14_phi_ && b_fjets14_phi_){
    b_fjets14_phi_->GetEntry(entry_);
    c_fjets14_phi_ = true;
  }
  return fjets14_phi_;
}

std::vector<float>* const & Baby::fjets14_pt() const{
  if(!c_fjets14_pt_ && b_fjets14_pt_){
    b_fjets14_pt_->GetEntry(entry_);
    c_fjets14_pt_ = true;
  }
  return fjets14_pt_;
}

std::vector<float>* const & Baby::fjets40_eta() const{
  if(!c_fjets40_eta_ && b_fjets40_eta_){
    b_fjets40_eta_->GetEntry(entry_);
    c_fjets40_eta_ = true;
  }
  return fjets40_eta_;
}

std::vector<float>* const & Baby::fjets40_m() const{
  if(!c_fjets40_m_ && b_fjets40_m_){
    b_fjets40_m_->GetEntry(entry_);
    c_fjets40_m_ = true;
  }
  return fjets40_m_;
}

std::vector<int>* const & Baby::fjets40_nconst() const{
  if(!c_fjets40_nconst_ && b_fjets40_nconst_){
    b_fjets40_nconst_->GetEntry(entry_);
    c_fjets40_nconst_ = true;
  }
  return fjets40_nconst_;
}

std::vector<float>* const & Baby::fjets40_phi() const{
  if(!c_fjets40_phi_ && b_fjets40_phi_){
    b_fjets40_phi_->GetEntry(entry_);
    c_fjets40_phi_ = true;
  }
  return fjets40_phi_;
}

std::vector<float>* const & Baby::fjets40_pt() const{
  if(!c_fjets40_pt_ && b_fjets40_pt_){
    b_fjets40_pt_->GetEntry(entry_);
    c_fjets40_pt_ = true;
  }
  return fjets40_pt_;
}

bool const & Baby::fromGS() const{
  if(!c_fromGS_ && b_fromGS_){
    b_fromGS_->GetEntry(entry_);
    c_fromGS_ = true;
  }
  return fromGS_;
}

float const & Baby::hig1_eta() const{
  if(!c_hig1_eta_ && b_hig1_eta_){
    b_hig1_eta_->GetEntry(entry_);
    c_hig1_eta_ = true;
  }
  return hig1_eta_;
}

float const & Baby::hig1_m() const{
  if(!c_hig1_m_ && b_hig1_m_){
    b_hig1_m_->GetEntry(entry_);
    c_hig1_m_ = true;
  }
  return hig1_m_;
}

float const & Baby::hig1_phi() const{
  if(!c_hig1_phi_ && b_hig1_phi_){
    b_hig1_phi_->GetEntry(entry_);
    c_hig1_phi_ = true;
  }
  return hig1_phi_;
}

float const & Baby::hig1_pt() const{
  if(!c_hig1_pt_ && b_hig1_pt_){
    b_hig1_pt_->GetEntry(entry_);
    c_hig1_pt_ = true;
  }
  return hig1_pt_;
}

float const & Baby::hig2_eta() const{
  if(!c_hig2_eta_ && b_hig2_eta_){
    b_hig2_eta_->GetEntry(entry_);
    c_hig2_eta_ = true;
  }
  return hig2_eta_;
}

float const & Baby::hig2_m() const{
  if(!c_hig2_m_ && b_hig2_m_){
    b_hig2_m_->GetEntry(entry_);
    c_hig2_m_ = true;
  }
  return hig2_m_;
}

float const & Baby::hig2_phi() const{
  if(!c_hig2_phi_ && b_hig2_phi_){
    b_hig2_phi_->GetEntry(entry_);
    c_hig2_phi_ = true;
  }
  return hig2_phi_;
}

float const & Baby::hig2_pt() const{
  if(!c_hig2_pt_ && b_hig2_pt_){
    b_hig2_pt_->GetEntry(entry_);
    c_hig2_pt_ = true;
  }
  return hig2_pt_;
}

float const & Baby::hig_am() const{
  if(!c_hig_am_ && b_hig_am_){
    b_hig_am_->GetEntry(entry_);
    c_hig_am_ = true;
  }
  return hig_am_;
}

int  const & Baby::hig_bin() const{
  if(!c_hig_bin_ && b_hig_bin_){
    b_hig_bin_->GetEntry(entry_);
    c_hig_bin_ = true;
  }
  return hig_bin_;
}

float const & Baby::hig_dm() const{
  if(!c_hig_dm_ && b_hig_dm_){
    b_hig_dm_->GetEntry(entry_);
    c_hig_dm_ = true;
  }
  return hig_dm_;
}

float const & Baby::hig_dphi() const{
  if(!c_hig_dphi_ && b_hig_dphi_){
    b_hig_dphi_->GetEntry(entry_);
    c_hig_dphi_ = true;
  }
  return hig_dphi_;
}

float const & Baby::hig_drmax() const{
  if(!c_hig_drmax_ && b_hig_drmax_){
    b_hig_drmax_->GetEntry(entry_);
    c_hig_drmax_ = true;
  }
  return hig_drmax_;
}

float const & Baby::ht() const{
  if(!c_ht_ && b_ht_){
    b_ht_->GetEntry(entry_);
    c_ht_ = true;
  }
  return ht_;
}

float const & Baby::ht40() const{
  if(!c_ht40_ && b_ht40_){
    b_ht40_->GetEntry(entry_);
    c_ht40_ = true;
  }
  return ht40_;
}

float const & Baby::ht50() const{
  if(!c_ht50_ && b_ht50_){
    b_ht50_->GetEntry(entry_);
    c_ht50_ = true;
  }
  return ht50_;
}

float const & Baby::ht_clean() const{
  if(!c_ht_clean_ && b_ht_clean_){
    b_ht_clean_->GetEntry(entry_);
    c_ht_clean_ = true;
  }
  return ht_clean_;
}

float const & Baby::ht_hlt() const{
  if(!c_ht_hlt_ && b_ht_hlt_){
    b_ht_hlt_->GetEntry(entry_);
    c_ht_hlt_ = true;
  }
  return ht_hlt_;
}

float const & Baby::ht_isr_me() const{
  if(!c_ht_isr_me_ && b_ht_isr_me_){
    b_ht_isr_me_->GetEntry(entry_);
    c_ht_isr_me_ = true;
  }
  return ht_isr_me_;
}

float const & Baby::ht_ra2() const{
  if(!c_ht_ra2_ && b_ht_ra2_){
    b_ht_ra2_->GetEntry(entry_);
    c_ht_ra2_ = true;
  }
  return ht_ra2_;
}

float const & Baby::ht_tru() const{
  if(!c_ht_tru_ && b_ht_tru_){
    b_ht_tru_->GetEntry(entry_);
    c_ht_tru_ = true;
  }
  return ht_tru_;
}

float const & Baby::htx() const{
  if(!c_htx_ && b_htx_){
    b_htx_->GetEntry(entry_);
    c_htx_ = true;
  }
  return htx_;
}

float const & Baby::htx40() const{
  if(!c_htx40_ && b_htx40_){
    b_htx40_->GetEntry(entry_);
    c_htx40_ = true;
  }
  return htx40_;
}

float const & Baby::htx50() const{
  if(!c_htx50_ && b_htx50_){
    b_htx50_->GetEntry(entry_);
    c_htx50_ = true;
  }
  return htx50_;
}

float const & Baby::isr_tru_eta() const{
  if(!c_isr_tru_eta_ && b_isr_tru_eta_){
    b_isr_tru_eta_->GetEntry(entry_);
    c_isr_tru_eta_ = true;
  }
  return isr_tru_eta_;
}

float const & Baby::isr_tru_phi() const{
  if(!c_isr_tru_phi_ && b_isr_tru_phi_){
    b_isr_tru_phi_->GetEntry(entry_);
    c_isr_tru_phi_ = true;
  }
  return isr_tru_phi_;
}

float const & Baby::isr_tru_pt() const{
  if(!c_isr_tru_pt_ && b_isr_tru_pt_){
    b_isr_tru_pt_->GetEntry(entry_);
    c_isr_tru_pt_ = true;
  }
  return isr_tru_pt_;
}

bool const & Baby::jetmismeas() const{
  if(!c_jetmismeas_ && b_jetmismeas_){
    b_jetmismeas_->GetEntry(entry_);
    c_jetmismeas_ = true;
  }
  return jetmismeas_;
}

std::vector<float>* const & Baby::jets_csv() const{
  if(!c_jets_csv_ && b_jets_csv_){
    b_jets_csv_->GetEntry(entry_);
    c_jets_csv_ = true;
  }
  return jets_csv_;
}

std::vector<float>* const & Baby::jets_eta() const{
  if(!c_jets_eta_ && b_jets_eta_){
    b_jets_eta_->GetEntry(entry_);
    c_jets_eta_ = true;
  }
  return jets_eta_;
}

std::vector<int> * const & Baby::jets_fjet08_index() const{
  if(!c_jets_fjet08_index_ && b_jets_fjet08_index_){
    b_jets_fjet08_index_->GetEntry(entry_);
    c_jets_fjet08_index_ = true;
  }
  return jets_fjet08_index_;
}

std::vector<int> * const & Baby::jets_fjet12_index() const{
  if(!c_jets_fjet12_index_ && b_jets_fjet12_index_){
    b_jets_fjet12_index_->GetEntry(entry_);
    c_jets_fjet12_index_ = true;
  }
  return jets_fjet12_index_;
}

std::vector<int> * const & Baby::jets_fjet14_index() const{
  if(!c_jets_fjet14_index_ && b_jets_fjet14_index_){
    b_jets_fjet14_index_->GetEntry(entry_);
    c_jets_fjet14_index_ = true;
  }
  return jets_fjet14_index_;
}

std::vector<int> * const & Baby::jets_fjet14_nolep_index() const{
  if(!c_jets_fjet14_nolep_index_ && b_jets_fjet14_nolep_index_){
    b_jets_fjet14_nolep_index_->GetEntry(entry_);
    c_jets_fjet14_nolep_index_ = true;
  }
  return jets_fjet14_nolep_index_;
}

std::vector<int> * const & Baby::jets_fjet40_index() const{
  if(!c_jets_fjet40_index_ && b_jets_fjet40_index_){
    b_jets_fjet40_index_->GetEntry(entry_);
    c_jets_fjet40_index_ = true;
  }
  return jets_fjet40_index_;
}

std::vector<int> * const & Baby::jets_fjet50_index() const{
  if(!c_jets_fjet50_index_ && b_jets_fjet50_index_){
    b_jets_fjet50_index_->GetEntry(entry_);
    c_jets_fjet50_index_ = true;
  }
  return jets_fjet50_index_;
}

std::vector<bool>* const & Baby::jets_h1() const{
  if(!c_jets_h1_ && b_jets_h1_){
    b_jets_h1_->GetEntry(entry_);
    c_jets_h1_ = true;
  }
  return jets_h1_;
}

std::vector<bool>* const & Baby::jets_h2() const{
  if(!c_jets_h2_ && b_jets_h2_){
    b_jets_h2_->GetEntry(entry_);
    c_jets_h2_ = true;
  }
  return jets_h2_;
}

std::vector<int> * const & Baby::jets_hflavor() const{
  if(!c_jets_hflavor_ && b_jets_hflavor_){
    b_jets_hflavor_->GetEntry(entry_);
    c_jets_hflavor_ = true;
  }
  return jets_hflavor_;
}

std::vector<bool>* const & Baby::jets_isisr() const{
  if(!c_jets_isisr_ && b_jets_isisr_){
    b_jets_isisr_->GetEntry(entry_);
    c_jets_isisr_ = true;
  }
  return jets_isisr_;
}

std::vector<bool>* const & Baby::jets_islep() const{
  if(!c_jets_islep_ && b_jets_islep_){
    b_jets_islep_->GetEntry(entry_);
    c_jets_islep_ = true;
  }
  return jets_islep_;
}

std::vector<float>* const & Baby::jets_m() const{
  if(!c_jets_m_ && b_jets_m_){
    b_jets_m_->GetEntry(entry_);
    c_jets_m_ = true;
  }
  return jets_m_;
}

std::vector<float>* const & Baby::jets_phi() const{
  if(!c_jets_phi_ && b_jets_phi_){
    b_jets_phi_->GetEntry(entry_);
    c_jets_phi_ = true;
  }
  return jets_phi_;
}

std::vector<float>* const & Baby::jets_pt() const{
  if(!c_jets_pt_ && b_jets_pt_){
    b_jets_pt_->GetEntry(entry_);
    c_jets_pt_ = true;
  }
  return jets_pt_;
}

std::vector<float>* const & Baby::jets_pt_res() const{
  if(!c_jets_pt_res_ && b_jets_pt_res_){
    b_jets_pt_res_->GetEntry(entry_);
    c_jets_pt_res_ = true;
  }
  return jets_pt_res_;
}

float const & Baby::jetsys_eta() const{
  if(!c_jetsys_eta_ && b_jetsys_eta_){
    b_jetsys_eta_->GetEntry(entry_);
    c_jetsys_eta_ = true;
  }
  return jetsys_eta_;
}

float const & Baby::jetsys_m() const{
  if(!c_jetsys_m_ && b_jetsys_m_){
    b_jetsys_m_->GetEntry(entry_);
    c_jetsys_m_ = true;
  }
  return jetsys_m_;
}

float const & Baby::jetsys_nob_eta() const{
  if(!c_jetsys_nob_eta_ && b_jetsys_nob_eta_){
    b_jetsys_nob_eta_->GetEntry(entry_);
    c_jetsys_nob_eta_ = true;
  }
  return jetsys_nob_eta_;
}

float const & Baby::jetsys_nob_m() const{
  if(!c_jetsys_nob_m_ && b_jetsys_nob_m_){
    b_jetsys_nob_m_->GetEntry(entry_);
    c_jetsys_nob_m_ = true;
  }
  return jetsys_nob_m_;
}

float const & Baby::jetsys_nob_phi() const{
  if(!c_jetsys_nob_phi_ && b_jetsys_nob_phi_){
    b_jetsys_nob_phi_->GetEntry(entry_);
    c_jetsys_nob_phi_ = true;
  }
  return jetsys_nob_phi_;
}

float const & Baby::jetsys_nob_pt() const{
  if(!c_jetsys_nob_pt_ && b_jetsys_nob_pt_){
    b_jetsys_nob_pt_->GetEntry(entry_);
    c_jetsys_nob_pt_ = true;
  }
  return jetsys_nob_pt_;
}

float const & Baby::jetsys_phi() const{
  if(!c_jetsys_phi_ && b_jetsys_phi_){
    b_jetsys_phi_->GetEntry(entry_);
    c_jetsys_phi_ = true;
  }
  return jetsys_phi_;
}

float const & Baby::jetsys_pt() const{
  if(!c_jetsys_pt_ && b_jetsys_pt_){
    b_jetsys_pt_->GetEntry(entry_);
    c_jetsys_pt_ = true;
  }
  return jetsys_pt_;
}

bool const & Baby::json12p9() const{
  if(!c_json12p9_ && b_json12p9_){
    b_json12p9_->GetEntry(entry_);
    c_json12p9_ = true;
  }
  return json12p9_;
}

bool const & Baby::json2p6() const{
  if(!c_json2p6_ && b_json2p6_){
    b_json2p6_->GetEntry(entry_);
    c_json2p6_ = true;
  }
  return json2p6_;
}

bool const & Baby::json4p0() const{
  if(!c_json4p0_ && b_json4p0_){
    b_json4p0_->GetEntry(entry_);
    c_json4p0_ = true;
  }
  return json4p0_;
}

bool const & Baby::json7p65() const{
  if(!c_json7p65_ && b_json7p65_){
    b_json7p65_->GetEntry(entry_);
    c_json7p65_ = true;
  }
  return json7p65_;
}

std::vector<float>* const & Baby::leps_eta() const{
  if(!c_leps_eta_ && b_leps_eta_){
    b_leps_eta_->GetEntry(entry_);
    c_leps_eta_ = true;
  }
  return leps_eta_;
}

std::vector<float>* const & Baby::leps_id() const{
  if(!c_leps_id_ && b_leps_id_){
    b_leps_id_->GetEntry(entry_);
    c_leps_id_ = true;
  }
  return leps_id_;
}

std::vector<float>* const & Baby::leps_phi() const{
  if(!c_leps_phi_ && b_leps_phi_){
    b_leps_phi_->GetEntry(entry_);
    c_leps_phi_ = true;
  }
  return leps_phi_;
}

std::vector<float>* const & Baby::leps_pt() const{
  if(!c_leps_pt_ && b_leps_pt_){
    b_leps_pt_->GetEntry(entry_);
    c_leps_pt_ = true;
  }
  return leps_pt_;
}

bool const & Baby::low_dphi() const{
  if(!c_low_dphi_ && b_low_dphi_){
    b_low_dphi_->GetEntry(entry_);
    c_low_dphi_ = true;
  }
  return low_dphi_;
}

int const & Baby::lumiblock() const{
  if(!c_lumiblock_ && b_lumiblock_){
    b_lumiblock_->GetEntry(entry_);
    c_lumiblock_ = true;
  }
  return lumiblock_;
}

float const & Baby::m_tt() const{
  if(!c_m_tt_ && b_m_tt_){
    b_m_tt_->GetEntry(entry_);
    c_m_tt_ = true;
  }
  return m_tt_;
}

std::vector<float>* const & Baby::mc_eta() const{
  if(!c_mc_eta_ && b_mc_eta_){
    b_mc_eta_->GetEntry(entry_);
    c_mc_eta_ = true;
  }
  return mc_eta_;
}

std::vector<int> * const & Baby::mc_id() const{
  if(!c_mc_id_ && b_mc_id_){
    b_mc_id_->GetEntry(entry_);
    c_mc_id_ = true;
  }
  return mc_id_;
}

std::vector<float>* const & Baby::mc_mass() const{
  if(!c_mc_mass_ && b_mc_mass_){
    b_mc_mass_->GetEntry(entry_);
    c_mc_mass_ = true;
  }
  return mc_mass_;
}

std::vector<int> * const & Baby::mc_mom() const{
  if(!c_mc_mom_ && b_mc_mom_){
    b_mc_mom_->GetEntry(entry_);
    c_mc_mom_ = true;
  }
  return mc_mom_;
}

std::vector<int> * const & Baby::mc_momidx() const{
  if(!c_mc_momidx_ && b_mc_momidx_){
    b_mc_momidx_->GetEntry(entry_);
    c_mc_momidx_ = true;
  }
  return mc_momidx_;
}

std::vector<float>* const & Baby::mc_phi() const{
  if(!c_mc_phi_ && b_mc_phi_){
    b_mc_phi_->GetEntry(entry_);
    c_mc_phi_ = true;
  }
  return mc_phi_;
}

std::vector<float>* const & Baby::mc_pt() const{
  if(!c_mc_pt_ && b_mc_pt_){
    b_mc_pt_->GetEntry(entry_);
    c_mc_pt_ = true;
  }
  return mc_pt_;
}

std::vector<int> * const & Baby::mc_status() const{
  if(!c_mc_status_ && b_mc_status_){
    b_mc_status_->GetEntry(entry_);
    c_mc_status_ = true;
  }
  return mc_status_;
}

float const & Baby::mct() const{
  if(!c_mct_ && b_mct_){
    b_mct_->GetEntry(entry_);
    c_mct_ = true;
  }
  return mct_;
}

float const & Baby::met() const{
  if(!c_met_ && b_met_){
    b_met_->GetEntry(entry_);
    c_met_ = true;
  }
  return met_;
}

float const & Baby::met_calo() const{
  if(!c_met_calo_ && b_met_calo_){
    b_met_calo_->GetEntry(entry_);
    c_met_calo_ = true;
  }
  return met_calo_;
}

float const & Baby::met_calo_phi() const{
  if(!c_met_calo_phi_ && b_met_calo_phi_){
    b_met_calo_phi_->GetEntry(entry_);
    c_met_calo_phi_ = true;
  }
  return met_calo_phi_;
}

float const & Baby::met_mini() const{
  if(!c_met_mini_ && b_met_mini_){
    b_met_mini_->GetEntry(entry_);
    c_met_mini_ = true;
  }
  return met_mini_;
}

float const & Baby::met_mini_phi() const{
  if(!c_met_mini_phi_ && b_met_mini_phi_){
    b_met_mini_phi_->GetEntry(entry_);
    c_met_mini_phi_ = true;
  }
  return met_mini_phi_;
}

float const & Baby::met_nohf() const{
  if(!c_met_nohf_ && b_met_nohf_){
    b_met_nohf_->GetEntry(entry_);
    c_met_nohf_ = true;
  }
  return met_nohf_;
}

float const & Baby::met_nohf_phi() const{
  if(!c_met_nohf_phi_ && b_met_nohf_phi_){
    b_met_nohf_phi_->GetEntry(entry_);
    c_met_nohf_phi_ = true;
  }
  return met_nohf_phi_;
}

float const & Baby::met_phi() const{
  if(!c_met_phi_ && b_met_phi_){
    b_met_phi_->GetEntry(entry_);
    c_met_phi_ = true;
  }
  return met_phi_;
}

float const & Baby::met_raw() const{
  if(!c_met_raw_ && b_met_raw_){
    b_met_raw_->GetEntry(entry_);
    c_met_raw_ = true;
  }
  return met_raw_;
}

float const & Baby::met_raw_phi() const{
  if(!c_met_raw_phi_ && b_met_raw_phi_){
    b_met_raw_phi_->GetEntry(entry_);
    c_met_raw_phi_ = true;
  }
  return met_raw_phi_;
}

float const & Baby::met_rebal() const{
  if(!c_met_rebal_ && b_met_rebal_){
    b_met_rebal_->GetEntry(entry_);
    c_met_rebal_ = true;
  }
  return met_rebal_;
}

float const & Baby::met_tru() const{
  if(!c_met_tru_ && b_met_tru_){
    b_met_tru_->GetEntry(entry_);
    c_met_tru_ = true;
  }
  return met_tru_;
}

float const & Baby::met_tru_nuw() const{
  if(!c_met_tru_nuw_ && b_met_tru_nuw_){
    b_met_tru_nuw_->GetEntry(entry_);
    c_met_tru_nuw_ = true;
  }
  return met_tru_nuw_;
}

float const & Baby::met_tru_nuw_phi() const{
  if(!c_met_tru_nuw_phi_ && b_met_tru_nuw_phi_){
    b_met_tru_nuw_phi_->GetEntry(entry_);
    c_met_tru_nuw_phi_ = true;
  }
  return met_tru_nuw_phi_;
}

float const & Baby::met_tru_phi() const{
  if(!c_met_tru_phi_ && b_met_tru_phi_){
    b_met_tru_phi_->GetEntry(entry_);
    c_met_tru_phi_ = true;
  }
  return met_tru_phi_;
}

int const & Baby::mgluino() const{
  if(!c_mgluino_ && b_mgluino_){
    b_mgluino_->GetEntry(entry_);
    c_mgluino_ = true;
  }
  return mgluino_;
}

float const & Baby::mht() const{
  if(!c_mht_ && b_mht_){
    b_mht_->GetEntry(entry_);
    c_mht_ = true;
  }
  return mht_;
}

float const & Baby::mht_clean() const{
  if(!c_mht_clean_ && b_mht_clean_){
    b_mht_clean_->GetEntry(entry_);
    c_mht_clean_ = true;
  }
  return mht_clean_;
}

float const & Baby::mht_clean_phi() const{
  if(!c_mht_clean_phi_ && b_mht_clean_phi_){
    b_mht_clean_phi_->GetEntry(entry_);
    c_mht_clean_phi_ = true;
  }
  return mht_clean_phi_;
}

float const & Baby::mht_phi() const{
  if(!c_mht_phi_ && b_mht_phi_){
    b_mht_phi_->GetEntry(entry_);
    c_mht_phi_ = true;
  }
  return mht_phi_;
}

float const & Baby::mj08() const{
  if(!c_mj08_ && b_mj08_){
    b_mj08_->GetEntry(entry_);
    c_mj08_ = true;
  }
  return mj08_;
}

float const & Baby::mj12() const{
  if(!c_mj12_ && b_mj12_){
    b_mj12_->GetEntry(entry_);
    c_mj12_ = true;
  }
  return mj12_;
}

float const & Baby::mj14() const{
  if(!c_mj14_ && b_mj14_){
    b_mj14_->GetEntry(entry_);
    c_mj14_ = true;
  }
  return mj14_;
}

float const & Baby::mj14_nolep() const{
  if(!c_mj14_nolep_ && b_mj14_nolep_){
    b_mj14_nolep_->GetEntry(entry_);
    c_mj14_nolep_ = true;
  }
  return mj14_nolep_;
}

float const & Baby::mj40() const{
  if(!c_mj40_ && b_mj40_){
    b_mj40_->GetEntry(entry_);
    c_mj40_ = true;
  }
  return mj40_;
}

float const & Baby::mj50() const{
  if(!c_mj50_ && b_mj50_){
    b_mj50_->GetEntry(entry_);
    c_mj50_ = true;
  }
  return mj50_;
}

int const & Baby::mlsp() const{
  if(!c_mlsp_ && b_mlsp_){
    b_mlsp_->GetEntry(entry_);
    c_mlsp_ = true;
  }
  return mlsp_;
}

std::vector<bool>* const & Baby::mm() const{
  if(!c_mm_ && b_mm_){
    b_mm_->GetEntry(entry_);
    c_mm_ = true;
  }
  return mm_;
}

std::vector<float>* const & Baby::mm_el_miniso() const{
  if(!c_mm_el_miniso_ && b_mm_el_miniso_){
    b_mm_el_miniso_->GetEntry(entry_);
    c_mm_el_miniso_ = true;
  }
  return mm_el_miniso_;
}

std::vector<float>* const & Baby::mm_el_pt() const{
  if(!c_mm_el_pt_ && b_mm_el_pt_){
    b_mm_el_pt_->GetEntry(entry_);
    c_mm_el_pt_ = true;
  }
  return mm_el_pt_;
}

std::vector<float>* const & Baby::mm_ht() const{
  if(!c_mm_ht_ && b_mm_ht_){
    b_mm_ht_->GetEntry(entry_);
    c_mm_ht_ = true;
  }
  return mm_ht_;
}

std::vector<float>* const & Baby::mm_jet_eta() const{
  if(!c_mm_jet_eta_ && b_mm_jet_eta_){
    b_mm_jet_eta_->GetEntry(entry_);
    c_mm_jet_eta_ = true;
  }
  return mm_jet_eta_;
}

std::vector<float>* const & Baby::mm_jet_m() const{
  if(!c_mm_jet_m_ && b_mm_jet_m_){
    b_mm_jet_m_->GetEntry(entry_);
    c_mm_jet_m_ = true;
  }
  return mm_jet_m_;
}

std::vector<float>* const & Baby::mm_jet_phi() const{
  if(!c_mm_jet_phi_ && b_mm_jet_phi_){
    b_mm_jet_phi_->GetEntry(entry_);
    c_mm_jet_phi_ = true;
  }
  return mm_jet_phi_;
}

std::vector<float>* const & Baby::mm_jet_pt() const{
  if(!c_mm_jet_pt_ && b_mm_jet_pt_){
    b_mm_jet_pt_->GetEntry(entry_);
    c_mm_jet_pt_ = true;
  }
  return mm_jet_pt_;
}

std::vector<float>* const & Baby::mm_lep_pt() const{
  if(!c_mm_lep_pt_ && b_mm_lep_pt_){
    b_mm_lep_pt_->GetEntry(entry_);
    c_mm_lep_pt_ = true;
  }
  return mm_lep_pt_;
}

std::vector<float>* const & Baby::mm_met() const{
  if(!c_mm_met_ && b_mm_met_){
    b_mm_met_->GetEntry(entry_);
    c_mm_met_ = true;
  }
  return mm_met_;
}

std::vector<float>* const & Baby::mm_met_phi() const{
  if(!c_mm_met_phi_ && b_mm_met_phi_){
    b_mm_met_phi_->GetEntry(entry_);
    c_mm_met_phi_ = true;
  }
  return mm_met_phi_;
}

std::vector<float>* const & Baby::mm_mj14_lep() const{
  if(!c_mm_mj14_lep_ && b_mm_mj14_lep_){
    b_mm_mj14_lep_->GetEntry(entry_);
    c_mm_mj14_lep_ = true;
  }
  return mm_mj14_lep_;
}

std::vector<float>* const & Baby::mm_mj14_nolep() const{
  if(!c_mm_mj14_nolep_ && b_mm_mj14_nolep_){
    b_mm_mj14_nolep_->GetEntry(entry_);
    c_mm_mj14_nolep_ = true;
  }
  return mm_mj14_nolep_;
}

std::vector<float>* const & Baby::mm_mt() const{
  if(!c_mm_mt_ && b_mm_mt_){
    b_mm_mt_->GetEntry(entry_);
    c_mm_mt_ = true;
  }
  return mm_mt_;
}

std::vector<float>* const & Baby::mm_mu_miniso() const{
  if(!c_mm_mu_miniso_ && b_mm_mu_miniso_){
    b_mm_mu_miniso_->GetEntry(entry_);
    c_mm_mu_miniso_ = true;
  }
  return mm_mu_miniso_;
}

std::vector<float>* const & Baby::mm_mu_pt() const{
  if(!c_mm_mu_pt_ && b_mm_mu_pt_){
    b_mm_mu_pt_->GetEntry(entry_);
    c_mm_mu_pt_ = true;
  }
  return mm_mu_pt_;
}

std::vector<int>* const & Baby::mm_nbm() const{
  if(!c_mm_nbm_ && b_mm_nbm_){
    b_mm_nbm_->GetEntry(entry_);
    c_mm_nbm_ = true;
  }
  return mm_nbm_;
}

std::vector<int>* const & Baby::mm_nels() const{
  if(!c_mm_nels_ && b_mm_nels_){
    b_mm_nels_->GetEntry(entry_);
    c_mm_nels_ = true;
  }
  return mm_nels_;
}

std::vector<int>* const & Baby::mm_njets() const{
  if(!c_mm_njets_ && b_mm_njets_){
    b_mm_njets_->GetEntry(entry_);
    c_mm_njets_ = true;
  }
  return mm_njets_;
}

std::vector<int>* const & Baby::mm_nleps() const{
  if(!c_mm_nleps_ && b_mm_nleps_){
    b_mm_nleps_->GetEntry(entry_);
    c_mm_nleps_ = true;
  }
  return mm_nleps_;
}

std::vector<int>* const & Baby::mm_nmus() const{
  if(!c_mm_nmus_ && b_mm_nmus_){
    b_mm_nmus_->GetEntry(entry_);
    c_mm_nmus_ = true;
  }
  return mm_nmus_;
}

float const & Baby::mt() const{
  if(!c_mt_ && b_mt_){
    b_mt_->GetEntry(entry_);
    c_mt_ = true;
  }
  return mt_;
}

float const & Baby::mt2() const{
  if(!c_mt2_ && b_mt2_){
    b_mt2_->GetEntry(entry_);
    c_mt2_ = true;
  }
  return mt2_;
}

float const & Baby::mt2_0mass() const{
  if(!c_mt2_0mass_ && b_mt2_0mass_){
    b_mt2_0mass_->GetEntry(entry_);
    c_mt2_0mass_ = true;
  }
  return mt2_0mass_;
}

float const & Baby::mt_nohf() const{
  if(!c_mt_nohf_ && b_mt_nohf_){
    b_mt_nohf_->GetEntry(entry_);
    c_mt_nohf_ = true;
  }
  return mt_nohf_;
}

float const & Baby::mt_rebal() const{
  if(!c_mt_rebal_ && b_mt_rebal_){
    b_mt_rebal_->GetEntry(entry_);
    c_mt_rebal_ = true;
  }
  return mt_rebal_;
}

float const & Baby::mt_tru() const{
  if(!c_mt_tru_ && b_mt_tru_){
    b_mt_tru_->GetEntry(entry_);
    c_mt_tru_ = true;
  }
  return mt_tru_;
}

float const & Baby::mt_tru_nuw() const{
  if(!c_mt_tru_nuw_ && b_mt_tru_nuw_){
    b_mt_tru_nuw_->GetEntry(entry_);
    c_mt_tru_nuw_ = true;
  }
  return mt_tru_nuw_;
}

float const & Baby::mumu_eta() const{
  if(!c_mumu_eta_ && b_mumu_eta_){
    b_mumu_eta_->GetEntry(entry_);
    c_mumu_eta_ = true;
  }
  return mumu_eta_;
}

float const & Baby::mumu_m() const{
  if(!c_mumu_m_ && b_mumu_m_){
    b_mumu_m_->GetEntry(entry_);
    c_mumu_m_ = true;
  }
  return mumu_m_;
}

float const & Baby::mumu_phi() const{
  if(!c_mumu_phi_ && b_mumu_phi_){
    b_mumu_phi_->GetEntry(entry_);
    c_mumu_phi_ = true;
  }
  return mumu_phi_;
}

float const & Baby::mumu_pt() const{
  if(!c_mumu_pt_ && b_mumu_pt_){
    b_mumu_pt_->GetEntry(entry_);
    c_mumu_pt_ = true;
  }
  return mumu_pt_;
}

float const & Baby::mumu_pt1() const{
  if(!c_mumu_pt1_ && b_mumu_pt1_){
    b_mumu_pt1_->GetEntry(entry_);
    c_mumu_pt1_ = true;
  }
  return mumu_pt1_;
}

float const & Baby::mumu_pt2() const{
  if(!c_mumu_pt2_ && b_mumu_pt2_){
    b_mumu_pt2_->GetEntry(entry_);
    c_mumu_pt2_ = true;
  }
  return mumu_pt2_;
}

float const & Baby::mumu_w() const{
  if(!c_mumu_w_ && b_mumu_w_){
    b_mumu_w_->GetEntry(entry_);
    c_mumu_w_ = true;
  }
  return mumu_w_;
}

float const & Baby::mumuv_eta() const{
  if(!c_mumuv_eta_ && b_mumuv_eta_){
    b_mumuv_eta_->GetEntry(entry_);
    c_mumuv_eta_ = true;
  }
  return mumuv_eta_;
}

float const & Baby::mumuv_m() const{
  if(!c_mumuv_m_ && b_mumuv_m_){
    b_mumuv_m_->GetEntry(entry_);
    c_mumuv_m_ = true;
  }
  return mumuv_m_;
}

float const & Baby::mumuv_phi() const{
  if(!c_mumuv_phi_ && b_mumuv_phi_){
    b_mumuv_phi_->GetEntry(entry_);
    c_mumuv_phi_ = true;
  }
  return mumuv_phi_;
}

float const & Baby::mumuv_pt() const{
  if(!c_mumuv_pt_ && b_mumuv_pt_){
    b_mumuv_pt_->GetEntry(entry_);
    c_mumuv_pt_ = true;
  }
  return mumuv_pt_;
}

float const & Baby::mumuv_pt1() const{
  if(!c_mumuv_pt1_ && b_mumuv_pt1_){
    b_mumuv_pt1_->GetEntry(entry_);
    c_mumuv_pt1_ = true;
  }
  return mumuv_pt1_;
}

float const & Baby::mumuv_pt2() const{
  if(!c_mumuv_pt2_ && b_mumuv_pt2_){
    b_mumuv_pt2_->GetEntry(entry_);
    c_mumuv_pt2_ = true;
  }
  return mumuv_pt2_;
}

float const & Baby::mumuv_w() const{
  if(!c_mumuv_w_ && b_mumuv_w_){
    b_mumuv_w_->GetEntry(entry_);
    c_mumuv_w_ = true;
  }
  return mumuv_w_;
}

std::vector<int>* const & Baby::mus_charge() const{
  if(!c_mus_charge_ && b_mus_charge_){
    b_mus_charge_->GetEntry(entry_);
    c_mus_charge_ = true;
  }
  return mus_charge_;
}

std::vector<float>* const & Baby::mus_d0() const{
  if(!c_mus_d0_ && b_mus_d0_){
    b_mus_d0_->GetEntry(entry_);
    c_mus_d0_ = true;
  }
  return mus_d0_;
}

std::vector<float>* const & Baby::mus_dz() const{
  if(!c_mus_dz_ && b_mus_dz_){
    b_mus_dz_->GetEntry(entry_);
    c_mus_dz_ = true;
  }
  return mus_dz_;
}

std::vector<float>* const & Baby::mus_em_e() const{
  if(!c_mus_em_e_ && b_mus_em_e_){
    b_mus_em_e_->GetEntry(entry_);
    c_mus_em_e_ = true;
  }
  return mus_em_e_;
}

std::vector<float>* const & Baby::mus_eta() const{
  if(!c_mus_eta_ && b_mus_eta_){
    b_mus_eta_->GetEntry(entry_);
    c_mus_eta_ = true;
  }
  return mus_eta_;
}

std::vector<float>* const & Baby::mus_had_e() const{
  if(!c_mus_had_e_ && b_mus_had_e_){
    b_mus_had_e_->GetEntry(entry_);
    c_mus_had_e_ = true;
  }
  return mus_had_e_;
}

std::vector<bool>* const & Baby::mus_inz() const{
  if(!c_mus_inz_ && b_mus_inz_){
    b_mus_inz_->GetEntry(entry_);
    c_mus_inz_ = true;
  }
  return mus_inz_;
}

std::vector<bool>* const & Baby::mus_inzv() const{
  if(!c_mus_inzv_ && b_mus_inzv_){
    b_mus_inzv_->GetEntry(entry_);
    c_mus_inzv_ = true;
  }
  return mus_inzv_;
}

std::vector<bool>* const & Baby::mus_isomu18() const{
  if(!c_mus_isomu18_ && b_mus_isomu18_){
    b_mus_isomu18_->GetEntry(entry_);
    c_mus_isomu18_ = true;
  }
  return mus_isomu18_;
}

std::vector<float>* const & Baby::mus_miniso() const{
  if(!c_mus_miniso_ && b_mus_miniso_){
    b_mus_miniso_->GetEntry(entry_);
    c_mus_miniso_ = true;
  }
  return mus_miniso_;
}

std::vector<bool>* const & Baby::mus_mu50() const{
  if(!c_mus_mu50_ && b_mus_mu50_){
    b_mus_mu50_->GetEntry(entry_);
    c_mus_mu50_ = true;
  }
  return mus_mu50_;
}

std::vector<bool>* const & Baby::mus_mu8() const{
  if(!c_mus_mu8_ && b_mus_mu8_){
    b_mus_mu8_->GetEntry(entry_);
    c_mus_mu8_ = true;
  }
  return mus_mu8_;
}

std::vector<float>* const & Baby::mus_phi() const{
  if(!c_mus_phi_ && b_mus_phi_){
    b_mus_phi_->GetEntry(entry_);
    c_mus_phi_ = true;
  }
  return mus_phi_;
}

std::vector<float>* const & Baby::mus_pt() const{
  if(!c_mus_pt_ && b_mus_pt_){
    b_mus_pt_->GetEntry(entry_);
    c_mus_pt_ = true;
  }
  return mus_pt_;
}

std::vector<float>* const & Baby::mus_pterr() const{
  if(!c_mus_pterr_ && b_mus_pterr_){
    b_mus_pterr_->GetEntry(entry_);
    c_mus_pterr_ = true;
  }
  return mus_pterr_;
}

std::vector<float>* const & Baby::mus_reliso() const{
  if(!c_mus_reliso_ && b_mus_reliso_){
    b_mus_reliso_->GetEntry(entry_);
    c_mus_reliso_ = true;
  }
  return mus_reliso_;
}

std::vector<bool>* const & Baby::mus_sig() const{
  if(!c_mus_sig_ && b_mus_sig_){
    b_mus_sig_->GetEntry(entry_);
    c_mus_sig_ = true;
  }
  return mus_sig_;
}

std::vector<bool>* const & Baby::mus_sigid() const{
  if(!c_mus_sigid_ && b_mus_sigid_){
    b_mus_sigid_->GetEntry(entry_);
    c_mus_sigid_ = true;
  }
  return mus_sigid_;
}

std::vector<bool>* const & Baby::mus_tight() const{
  if(!c_mus_tight_ && b_mus_tight_){
    b_mus_tight_->GetEntry(entry_);
    c_mus_tight_ = true;
  }
  return mus_tight_;
}

std::vector<bool>* const & Baby::mus_tm() const{
  if(!c_mus_tm_ && b_mus_tm_){
    b_mus_tm_->GetEntry(entry_);
    c_mus_tm_ = true;
  }
  return mus_tm_;
}

std::vector<int>* const & Baby::mus_trk_algo() const{
  if(!c_mus_trk_algo_ && b_mus_trk_algo_){
    b_mus_trk_algo_->GetEntry(entry_);
    c_mus_trk_algo_ = true;
  }
  return mus_trk_algo_;
}

std::vector<int>* const & Baby::mus_trk_nholes_in() const{
  if(!c_mus_trk_nholes_in_ && b_mus_trk_nholes_in_){
    b_mus_trk_nholes_in_->GetEntry(entry_);
    c_mus_trk_nholes_in_ = true;
  }
  return mus_trk_nholes_in_;
}

std::vector<int>* const & Baby::mus_trk_nholes_out() const{
  if(!c_mus_trk_nholes_out_ && b_mus_trk_nholes_out_){
    b_mus_trk_nholes_out_->GetEntry(entry_);
    c_mus_trk_nholes_out_ = true;
  }
  return mus_trk_nholes_out_;
}

std::vector<bool>* const & Baby::mus_trk_quality() const{
  if(!c_mus_trk_quality_ && b_mus_trk_quality_){
    b_mus_trk_quality_->GetEntry(entry_);
    c_mus_trk_quality_ = true;
  }
  return mus_trk_quality_;
}

std::vector<bool>* const & Baby::mus_vvvl() const{
  if(!c_mus_vvvl_ && b_mus_vvvl_){
    b_mus_vvvl_->GetEntry(entry_);
    c_mus_vvvl_ = true;
  }
  return mus_vvvl_;
}

std::vector<float>* const & Baby::mus_vvvl_eta() const{
  if(!c_mus_vvvl_eta_ && b_mus_vvvl_eta_){
    b_mus_vvvl_eta_->GetEntry(entry_);
    c_mus_vvvl_eta_ = true;
  }
  return mus_vvvl_eta_;
}

std::vector<float>* const & Baby::mus_vvvl_phi() const{
  if(!c_mus_vvvl_phi_ && b_mus_vvvl_phi_){
    b_mus_vvvl_phi_->GetEntry(entry_);
    c_mus_vvvl_phi_ = true;
  }
  return mus_vvvl_phi_;
}

std::vector<float>* const & Baby::mus_vvvl_pt() const{
  if(!c_mus_vvvl_pt_ && b_mus_vvvl_pt_){
    b_mus_vvvl_pt_->GetEntry(entry_);
    c_mus_vvvl_pt_ = true;
  }
  return mus_vvvl_pt_;
}

int const & Baby::nbl() const{
  if(!c_nbl_ && b_nbl_){
    b_nbl_->GetEntry(entry_);
    c_nbl_ = true;
  }
  return nbl_;
}

int const & Baby::nbm() const{
  if(!c_nbm_ && b_nbm_){
    b_nbm_->GetEntry(entry_);
    c_nbm_ = true;
  }
  return nbm_;
}

int const & Baby::nbm20() const{
  if(!c_nbm20_ && b_nbm20_){
    b_nbm20_->GetEntry(entry_);
    c_nbm20_ = true;
  }
  return nbm20_;
}

int const & Baby::nbm40() const{
  if(!c_nbm40_ && b_nbm40_){
    b_nbm40_->GetEntry(entry_);
    c_nbm40_ = true;
  }
  return nbm40_;
}

int const & Baby::nbm50() const{
  if(!c_nbm50_ && b_nbm50_){
    b_nbm50_->GetEntry(entry_);
    c_nbm50_ = true;
  }
  return nbm50_;
}

int const & Baby::nbm_ra2() const{
  if(!c_nbm_ra2_ && b_nbm_ra2_){
    b_nbm_ra2_->GetEntry(entry_);
    c_nbm_ra2_ = true;
  }
  return nbm_ra2_;
}

int const & Baby::nbt() const{
  if(!c_nbt_ && b_nbt_){
    b_nbt_->GetEntry(entry_);
    c_nbt_ = true;
  }
  return nbt_;
}

int const & Baby::nels() const{
  if(!c_nels_ && b_nels_){
    b_nels_->GetEntry(entry_);
    c_nels_ = true;
  }
  return nels_;
}

int const & Baby::nels_ele23() const{
  if(!c_nels_ele23_ && b_nels_ele23_){
    b_nels_ele23_->GetEntry(entry_);
    c_nels_ele23_ = true;
  }
  return nels_ele23_;
}

int const & Baby::nels_vvvl() const{
  if(!c_nels_vvvl_ && b_nels_vvvl_){
    b_nels_vvvl_->GetEntry(entry_);
    c_nels_vvvl_ = true;
  }
  return nels_vvvl_;
}

int const & Baby::nfjets14() const{
  if(!c_nfjets14_ && b_nfjets14_){
    b_nfjets14_->GetEntry(entry_);
    c_nfjets14_ = true;
  }
  return nfjets14_;
}

int const & Baby::nfjets40() const{
  if(!c_nfjets40_ && b_nfjets40_){
    b_nfjets40_->GetEntry(entry_);
    c_nfjets40_ = true;
  }
  return nfjets40_;
}

float const & Baby::nisr() const{
  if(!c_nisr_ && b_nisr_){
    b_nisr_->GetEntry(entry_);
    c_nisr_ = true;
  }
  return nisr_;
}

int const & Baby::nisr_me() const{
  if(!c_nisr_me_ && b_nisr_me_){
    b_nisr_me_->GetEntry(entry_);
    c_nisr_me_ = true;
  }
  return nisr_me_;
}

int const & Baby::njets() const{
  if(!c_njets_ && b_njets_){
    b_njets_->GetEntry(entry_);
    c_njets_ = true;
  }
  return njets_;
}

int const & Baby::njets20() const{
  if(!c_njets20_ && b_njets20_){
    b_njets20_->GetEntry(entry_);
    c_njets20_ = true;
  }
  return njets20_;
}

int const & Baby::njets40() const{
  if(!c_njets40_ && b_njets40_){
    b_njets40_->GetEntry(entry_);
    c_njets40_ = true;
  }
  return njets40_;
}

int const & Baby::njets50() const{
  if(!c_njets50_ && b_njets50_){
    b_njets50_->GetEntry(entry_);
    c_njets50_ = true;
  }
  return njets50_;
}

int const & Baby::njets_clean() const{
  if(!c_njets_clean_ && b_njets_clean_){
    b_njets_clean_->GetEntry(entry_);
    c_njets_clean_ = true;
  }
  return njets_clean_;
}

int const & Baby::njets_ra2() const{
  if(!c_njets_ra2_ && b_njets_ra2_){
    b_njets_ra2_->GetEntry(entry_);
    c_njets_ra2_ = true;
  }
  return njets_ra2_;
}

int const & Baby::nleps() const{
  if(!c_nleps_ && b_nleps_){
    b_nleps_->GetEntry(entry_);
    c_nleps_ = true;
  }
  return nleps_;
}

int const & Baby::nleps_tm() const{
  if(!c_nleps_tm_ && b_nleps_tm_){
    b_nleps_tm_->GetEntry(entry_);
    c_nleps_tm_ = true;
  }
  return nleps_tm_;
}

int const & Baby::nmus() const{
  if(!c_nmus_ && b_nmus_){
    b_nmus_->GetEntry(entry_);
    c_nmus_ = true;
  }
  return nmus_;
}

int const & Baby::nmus_isomu18() const{
  if(!c_nmus_isomu18_ && b_nmus_isomu18_){
    b_nmus_isomu18_->GetEntry(entry_);
    c_nmus_isomu18_ = true;
  }
  return nmus_isomu18_;
}

int const & Baby::nmus_vvvl() const{
  if(!c_nmus_vvvl_ && b_nmus_vvvl_){
    b_nmus_vvvl_->GetEntry(entry_);
    c_nmus_vvvl_ = true;
  }
  return nmus_vvvl_;
}

bool const & Baby::nonblind() const{
  if(!c_nonblind_ && b_nonblind_){
    b_nonblind_->GetEntry(entry_);
    c_nonblind_ = true;
  }
  return nonblind_;
}

int const & Baby::nph() const{
  if(!c_nph_ && b_nph_){
    b_nph_->GetEntry(entry_);
    c_nph_ = true;
  }
  return nph_;
}

int const & Baby::npv() const{
  if(!c_npv_ && b_npv_){
    b_npv_->GetEntry(entry_);
    c_npv_ = true;
  }
  return npv_;
}

int const & Baby::ntks() const{
  if(!c_ntks_ && b_ntks_){
    b_ntks_->GetEntry(entry_);
    c_ntks_ = true;
  }
  return ntks_;
}

int const & Baby::ntruels() const{
  if(!c_ntruels_ && b_ntruels_){
    b_ntruels_->GetEntry(entry_);
    c_ntruels_ = true;
  }
  return ntruels_;
}

int const & Baby::ntruleps() const{
  if(!c_ntruleps_ && b_ntruleps_){
    b_ntruleps_->GetEntry(entry_);
    c_ntruleps_ = true;
  }
  return ntruleps_;
}

int const & Baby::ntrumus() const{
  if(!c_ntrumus_ && b_ntrumus_){
    b_ntrumus_->GetEntry(entry_);
    c_ntrumus_ = true;
  }
  return ntrumus_;
}

int const & Baby::ntrupv() const{
  if(!c_ntrupv_ && b_ntrupv_){
    b_ntrupv_->GetEntry(entry_);
    c_ntrupv_ = true;
  }
  return ntrupv_;
}

float const & Baby::ntrupv_mean() const{
  if(!c_ntrupv_mean_ && b_ntrupv_mean_){
    b_ntrupv_mean_->GetEntry(entry_);
    c_ntrupv_mean_ = true;
  }
  return ntrupv_mean_;
}

int const & Baby::ntrutaush() const{
  if(!c_ntrutaush_ && b_ntrutaush_){
    b_ntrutaush_->GetEntry(entry_);
    c_ntrutaush_ = true;
  }
  return ntrutaush_;
}

int const & Baby::ntrutausl() const{
  if(!c_ntrutausl_ && b_ntrutausl_){
    b_ntrutausl_->GetEntry(entry_);
    c_ntrutausl_ = true;
  }
  return ntrutausl_;
}

int const & Baby::nvels() const{
  if(!c_nvels_ && b_nvels_){
    b_nvels_->GetEntry(entry_);
    c_nvels_ = true;
  }
  return nvels_;
}

int const & Baby::nveto() const{
  if(!c_nveto_ && b_nveto_){
    b_nveto_->GetEntry(entry_);
    c_nveto_ = true;
  }
  return nveto_;
}

int const & Baby::nvleps() const{
  if(!c_nvleps_ && b_nvleps_){
    b_nvleps_->GetEntry(entry_);
    c_nvleps_ = true;
  }
  return nvleps_;
}

int const & Baby::nvmus() const{
  if(!c_nvmus_ && b_nvmus_){
    b_nvmus_->GetEntry(entry_);
    c_nvmus_ = true;
  }
  return nvmus_;
}

float const & Baby::onel_ele105() const{
  if(!c_onel_ele105_ && b_onel_ele105_){
    b_onel_ele105_->GetEntry(entry_);
    c_onel_ele105_ = true;
  }
  return onel_ele105_;
}

float const & Baby::onel_ele23() const{
  if(!c_onel_ele23_ && b_onel_ele23_){
    b_onel_ele23_->GetEntry(entry_);
    c_onel_ele23_ = true;
  }
  return onel_ele23_;
}

float const & Baby::onel_ele8() const{
  if(!c_onel_ele8_ && b_onel_ele8_){
    b_onel_ele8_->GetEntry(entry_);
    c_onel_ele8_ = true;
  }
  return onel_ele8_;
}

float const & Baby::onel_vvvl() const{
  if(!c_onel_vvvl_ && b_onel_vvvl_){
    b_onel_vvvl_->GetEntry(entry_);
    c_onel_vvvl_ = true;
  }
  return onel_vvvl_;
}

float const & Baby::onht() const{
  if(!c_onht_ && b_onht_){
    b_onht_->GetEntry(entry_);
    c_onht_ = true;
  }
  return onht_;
}

float const & Baby::onmet() const{
  if(!c_onmet_ && b_onmet_){
    b_onmet_->GetEntry(entry_);
    c_onmet_ = true;
  }
  return onmet_;
}

float const & Baby::onmu_isomu18() const{
  if(!c_onmu_isomu18_ && b_onmu_isomu18_){
    b_onmu_isomu18_->GetEntry(entry_);
    c_onmu_isomu18_ = true;
  }
  return onmu_isomu18_;
}

float const & Baby::onmu_mu50() const{
  if(!c_onmu_mu50_ && b_onmu_mu50_){
    b_onmu_mu50_->GetEntry(entry_);
    c_onmu_mu50_ = true;
  }
  return onmu_mu50_;
}

float const & Baby::onmu_mu8() const{
  if(!c_onmu_mu8_ && b_onmu_mu8_){
    b_onmu_mu8_->GetEntry(entry_);
    c_onmu_mu8_ = true;
  }
  return onmu_mu8_;
}

float const & Baby::onmu_vvvl() const{
  if(!c_onmu_vvvl_ && b_onmu_vvvl_){
    b_onmu_vvvl_->GetEntry(entry_);
    c_onmu_vvvl_ = true;
  }
  return onmu_vvvl_;
}

float const & Baby::onph_ph90() const{
  if(!c_onph_ph90_ && b_onph_ph90_){
    b_onph_ph90_->GetEntry(entry_);
    c_onph_ph90_ = true;
  }
  return onph_ph90_;
}

bool const & Baby::pass() const{
  if(!c_pass_ && b_pass_){
    b_pass_->GetEntry(entry_);
    c_pass_ = true;
  }
  return pass_;
}

bool const & Baby::pass20() const{
  if(!c_pass20_ && b_pass20_){
    b_pass20_->GetEntry(entry_);
    c_pass20_ = true;
  }
  return pass20_;
}

bool const & Baby::pass40() const{
  if(!c_pass40_ && b_pass40_){
    b_pass40_->GetEntry(entry_);
    c_pass40_ = true;
  }
  return pass40_;
}

bool const & Baby::pass50() const{
  if(!c_pass50_ && b_pass50_){
    b_pass50_->GetEntry(entry_);
    c_pass50_ = true;
  }
  return pass50_;
}

bool const & Baby::pass_cschalo() const{
  if(!c_pass_cschalo_ && b_pass_cschalo_){
    b_pass_cschalo_->GetEntry(entry_);
    c_pass_cschalo_ = true;
  }
  return pass_cschalo_;
}

bool const & Baby::pass_ecaldeadcell() const{
  if(!c_pass_ecaldeadcell_ && b_pass_ecaldeadcell_){
    b_pass_ecaldeadcell_->GetEntry(entry_);
    c_pass_ecaldeadcell_ = true;
  }
  return pass_ecaldeadcell_;
}

bool const & Baby::pass_eebadsc() const{
  if(!c_pass_eebadsc_ && b_pass_eebadsc_){
    b_pass_eebadsc_->GetEntry(entry_);
    c_pass_eebadsc_ = true;
  }
  return pass_eebadsc_;
}

bool const & Baby::pass_goodv() const{
  if(!c_pass_goodv_ && b_pass_goodv_){
    b_pass_goodv_->GetEntry(entry_);
    c_pass_goodv_ = true;
  }
  return pass_goodv_;
}

bool const & Baby::pass_hbhe() const{
  if(!c_pass_hbhe_ && b_pass_hbhe_){
    b_pass_hbhe_->GetEntry(entry_);
    c_pass_hbhe_ = true;
  }
  return pass_hbhe_;
}

bool const & Baby::pass_hbheiso() const{
  if(!c_pass_hbheiso_ && b_pass_hbheiso_){
    b_pass_hbheiso_->GetEntry(entry_);
    c_pass_hbheiso_ = true;
  }
  return pass_hbheiso_;
}

bool const & Baby::pass_jets() const{
  if(!c_pass_jets_ && b_pass_jets_){
    b_pass_jets_->GetEntry(entry_);
    c_pass_jets_ = true;
  }
  return pass_jets_;
}

bool const & Baby::pass_jets20() const{
  if(!c_pass_jets20_ && b_pass_jets20_){
    b_pass_jets20_->GetEntry(entry_);
    c_pass_jets20_ = true;
  }
  return pass_jets20_;
}

bool const & Baby::pass_jets40() const{
  if(!c_pass_jets40_ && b_pass_jets40_){
    b_pass_jets40_->GetEntry(entry_);
    c_pass_jets40_ = true;
  }
  return pass_jets40_;
}

bool const & Baby::pass_jets50() const{
  if(!c_pass_jets50_ && b_pass_jets50_){
    b_pass_jets50_->GetEntry(entry_);
    c_pass_jets50_ = true;
  }
  return pass_jets50_;
}

bool const & Baby::pass_jets_nohf() const{
  if(!c_pass_jets_nohf_ && b_pass_jets_nohf_){
    b_pass_jets_nohf_->GetEntry(entry_);
    c_pass_jets_nohf_ = true;
  }
  return pass_jets_nohf_;
}

bool const & Baby::pass_jets_ra2() const{
  if(!c_pass_jets_ra2_ && b_pass_jets_ra2_){
    b_pass_jets_ra2_->GetEntry(entry_);
    c_pass_jets_ra2_ = true;
  }
  return pass_jets_ra2_;
}

bool const & Baby::pass_jets_tight() const{
  if(!c_pass_jets_tight_ && b_pass_jets_tight_){
    b_pass_jets_tight_->GetEntry(entry_);
    c_pass_jets_tight_ = true;
  }
  return pass_jets_tight_;
}

bool const & Baby::pass_jets_tight_ra2() const{
  if(!c_pass_jets_tight_ra2_ && b_pass_jets_tight_ra2_){
    b_pass_jets_tight_ra2_->GetEntry(entry_);
    c_pass_jets_tight_ra2_ = true;
  }
  return pass_jets_tight_ra2_;
}

bool const & Baby::pass_nohf() const{
  if(!c_pass_nohf_ && b_pass_nohf_){
    b_pass_nohf_->GetEntry(entry_);
    c_pass_nohf_ = true;
  }
  return pass_nohf_;
}

bool const & Baby::pass_ra2() const{
  if(!c_pass_ra2_ && b_pass_ra2_){
    b_pass_ra2_->GetEntry(entry_);
    c_pass_ra2_ = true;
  }
  return pass_ra2_;
}

bool const & Baby::pass_ra2_badmu() const{
  if(!c_pass_ra2_badmu_ && b_pass_ra2_badmu_){
    b_pass_ra2_badmu_->GetEntry(entry_);
    c_pass_ra2_badmu_ = true;
  }
  return pass_ra2_badmu_;
}

std::vector<float>* const & Baby::ph_eta() const{
  if(!c_ph_eta_ && b_ph_eta_){
    b_ph_eta_->GetEntry(entry_);
    c_ph_eta_ = true;
  }
  return ph_eta_;
}

std::vector<bool>* const & Baby::ph_ph90() const{
  if(!c_ph_ph90_ && b_ph_ph90_){
    b_ph_ph90_->GetEntry(entry_);
    c_ph_ph90_ = true;
  }
  return ph_ph90_;
}

std::vector<float>* const & Baby::ph_phi() const{
  if(!c_ph_phi_ && b_ph_phi_){
    b_ph_phi_->GetEntry(entry_);
    c_ph_phi_ = true;
  }
  return ph_phi_;
}

std::vector<float>* const & Baby::ph_pt() const{
  if(!c_ph_pt_ && b_ph_pt_){
    b_ph_pt_->GetEntry(entry_);
    c_ph_pt_ = true;
  }
  return ph_pt_;
}

std::vector<bool>* const & Baby::ph_tm() const{
  if(!c_ph_tm_ && b_ph_tm_){
    b_ph_tm_->GetEntry(entry_);
    c_ph_tm_ = true;
  }
  return ph_tm_;
}

int const & Baby::run() const{
  if(!c_run_ && b_run_){
    b_run_->GetEntry(entry_);
    c_run_ = true;
  }
  return run_;
}

float const & Baby::st() const{
  if(!c_st_ && b_st_){
    b_st_->GetEntry(entry_);
    c_st_ = true;
  }
  return st_;
}

float const & Baby::st40() const{
  if(!c_st40_ && b_st40_){
    b_st40_->GetEntry(entry_);
    c_st40_ = true;
  }
  return st40_;
}

float const & Baby::st50() const{
  if(!c_st50_ && b_st50_){
    b_st50_->GetEntry(entry_);
    c_st50_ = true;
  }
  return st50_;
}

bool const & Baby::stitch() const{
  if(!c_stitch_ && b_stitch_){
    b_stitch_->GetEntry(entry_);
    c_stitch_ = true;
  }
  return stitch_;
}

std::vector<float>* const & Baby::sys_bctag() const{
  if(!c_sys_bctag_ && b_sys_bctag_){
    b_sys_bctag_->GetEntry(entry_);
    c_sys_bctag_ = true;
  }
  return sys_bctag_;
}

std::vector<float>* const & Baby::sys_bctag40() const{
  if(!c_sys_bctag40_ && b_sys_bctag40_){
    b_sys_bctag40_->GetEntry(entry_);
    c_sys_bctag40_ = true;
  }
  return sys_bctag40_;
}

std::vector<float>* const & Baby::sys_bctag_loose() const{
  if(!c_sys_bctag_loose_ && b_sys_bctag_loose_){
    b_sys_bctag_loose_->GetEntry(entry_);
    c_sys_bctag_loose_ = true;
  }
  return sys_bctag_loose_;
}

std::vector<float>* const & Baby::sys_fs_bctag() const{
  if(!c_sys_fs_bctag_ && b_sys_fs_bctag_){
    b_sys_fs_bctag_->GetEntry(entry_);
    c_sys_fs_bctag_ = true;
  }
  return sys_fs_bctag_;
}

std::vector<float>* const & Baby::sys_fs_bctag40() const{
  if(!c_sys_fs_bctag40_ && b_sys_fs_bctag40_){
    b_sys_fs_bctag40_->GetEntry(entry_);
    c_sys_fs_bctag40_ = true;
  }
  return sys_fs_bctag40_;
}

std::vector<float>* const & Baby::sys_fs_lep() const{
  if(!c_sys_fs_lep_ && b_sys_fs_lep_){
    b_sys_fs_lep_->GetEntry(entry_);
    c_sys_fs_lep_ = true;
  }
  return sys_fs_lep_;
}

std::vector<float>* const & Baby::sys_fs_udsgtag() const{
  if(!c_sys_fs_udsgtag_ && b_sys_fs_udsgtag_){
    b_sys_fs_udsgtag_->GetEntry(entry_);
    c_sys_fs_udsgtag_ = true;
  }
  return sys_fs_udsgtag_;
}

std::vector<float>* const & Baby::sys_fs_udsgtag40() const{
  if(!c_sys_fs_udsgtag40_ && b_sys_fs_udsgtag40_){
    b_sys_fs_udsgtag40_->GetEntry(entry_);
    c_sys_fs_udsgtag40_ = true;
  }
  return sys_fs_udsgtag40_;
}

std::vector<float>* const & Baby::sys_ht() const{
  if(!c_sys_ht_ && b_sys_ht_){
    b_sys_ht_->GetEntry(entry_);
    c_sys_ht_ = true;
  }
  return sys_ht_;
}

std::vector<float>* const & Baby::sys_ht40() const{
  if(!c_sys_ht40_ && b_sys_ht40_){
    b_sys_ht40_->GetEntry(entry_);
    c_sys_ht40_ = true;
  }
  return sys_ht40_;
}

std::vector<float>* const & Baby::sys_isr() const{
  if(!c_sys_isr_ && b_sys_isr_){
    b_sys_isr_->GetEntry(entry_);
    c_sys_isr_ = true;
  }
  return sys_isr_;
}

std::vector<float>* const & Baby::sys_lep() const{
  if(!c_sys_lep_ && b_sys_lep_){
    b_sys_lep_->GetEntry(entry_);
    c_sys_lep_ = true;
  }
  return sys_lep_;
}

std::vector<float>* const & Baby::sys_met() const{
  if(!c_sys_met_ && b_sys_met_){
    b_sys_met_->GetEntry(entry_);
    c_sys_met_ = true;
  }
  return sys_met_;
}

std::vector<float>* const & Baby::sys_mj14() const{
  if(!c_sys_mj14_ && b_sys_mj14_){
    b_sys_mj14_->GetEntry(entry_);
    c_sys_mj14_ = true;
  }
  return sys_mj14_;
}

std::vector<float>* const & Baby::sys_mj14_nolep() const{
  if(!c_sys_mj14_nolep_ && b_sys_mj14_nolep_){
    b_sys_mj14_nolep_->GetEntry(entry_);
    c_sys_mj14_nolep_ = true;
  }
  return sys_mj14_nolep_;
}

std::vector<float>* const & Baby::sys_mj40() const{
  if(!c_sys_mj40_ && b_sys_mj40_){
    b_sys_mj40_->GetEntry(entry_);
    c_sys_mj40_ = true;
  }
  return sys_mj40_;
}

std::vector<float>* const & Baby::sys_mt() const{
  if(!c_sys_mt_ && b_sys_mt_){
    b_sys_mt_->GetEntry(entry_);
    c_sys_mt_ = true;
  }
  return sys_mt_;
}

std::vector<float>* const & Baby::sys_muf() const{
  if(!c_sys_muf_ && b_sys_muf_){
    b_sys_muf_->GetEntry(entry_);
    c_sys_muf_ = true;
  }
  return sys_muf_;
}

std::vector<float>* const & Baby::sys_mur() const{
  if(!c_sys_mur_ && b_sys_mur_){
    b_sys_mur_->GetEntry(entry_);
    c_sys_mur_ = true;
  }
  return sys_mur_;
}

std::vector<float>* const & Baby::sys_murf() const{
  if(!c_sys_murf_ && b_sys_murf_){
    b_sys_murf_->GetEntry(entry_);
    c_sys_murf_ = true;
  }
  return sys_murf_;
}

std::vector<int> * const & Baby::sys_nbm() const{
  if(!c_sys_nbm_ && b_sys_nbm_){
    b_sys_nbm_->GetEntry(entry_);
    c_sys_nbm_ = true;
  }
  return sys_nbm_;
}

std::vector<int> * const & Baby::sys_nbm40() const{
  if(!c_sys_nbm40_ && b_sys_nbm40_){
    b_sys_nbm40_->GetEntry(entry_);
    c_sys_nbm40_ = true;
  }
  return sys_nbm40_;
}

std::vector<int> * const & Baby::sys_njets() const{
  if(!c_sys_njets_ && b_sys_njets_){
    b_sys_njets_->GetEntry(entry_);
    c_sys_njets_ = true;
  }
  return sys_njets_;
}

std::vector<int> * const & Baby::sys_njets40() const{
  if(!c_sys_njets40_ && b_sys_njets40_){
    b_sys_njets40_->GetEntry(entry_);
    c_sys_njets40_ = true;
  }
  return sys_njets40_;
}

std::vector<bool>* const & Baby::sys_pass() const{
  if(!c_sys_pass_ && b_sys_pass_){
    b_sys_pass_->GetEntry(entry_);
    c_sys_pass_ = true;
  }
  return sys_pass_;
}

std::vector<bool>* const & Baby::sys_pass40() const{
  if(!c_sys_pass40_ && b_sys_pass40_){
    b_sys_pass40_->GetEntry(entry_);
    c_sys_pass40_ = true;
  }
  return sys_pass40_;
}

std::vector<float>* const & Baby::sys_pu() const{
  if(!c_sys_pu_ && b_sys_pu_){
    b_sys_pu_->GetEntry(entry_);
    c_sys_pu_ = true;
  }
  return sys_pu_;
}

std::vector<float>* const & Baby::sys_st() const{
  if(!c_sys_st_ && b_sys_st_){
    b_sys_st_->GetEntry(entry_);
    c_sys_st_ = true;
  }
  return sys_st_;
}

std::vector<float>* const & Baby::sys_st40() const{
  if(!c_sys_st40_ && b_sys_st40_){
    b_sys_st40_->GetEntry(entry_);
    c_sys_st40_ = true;
  }
  return sys_st40_;
}

std::vector<float>* const & Baby::sys_trig() const{
  if(!c_sys_trig_ && b_sys_trig_){
    b_sys_trig_->GetEntry(entry_);
    c_sys_trig_ = true;
  }
  return sys_trig_;
}

std::vector<float>* const & Baby::sys_udsgtag() const{
  if(!c_sys_udsgtag_ && b_sys_udsgtag_){
    b_sys_udsgtag_->GetEntry(entry_);
    c_sys_udsgtag_ = true;
  }
  return sys_udsgtag_;
}

std::vector<float>* const & Baby::sys_udsgtag40() const{
  if(!c_sys_udsgtag40_ && b_sys_udsgtag40_){
    b_sys_udsgtag40_->GetEntry(entry_);
    c_sys_udsgtag40_ = true;
  }
  return sys_udsgtag40_;
}

std::vector<float>* const & Baby::sys_udsgtag_loose() const{
  if(!c_sys_udsgtag_loose_ && b_sys_udsgtag_loose_){
    b_sys_udsgtag_loose_->GetEntry(entry_);
    c_sys_udsgtag_loose_ = true;
  }
  return sys_udsgtag_loose_;
}

std::vector<float>* const & Baby::tks_d0() const{
  if(!c_tks_d0_ && b_tks_d0_){
    b_tks_d0_->GetEntry(entry_);
    c_tks_d0_ = true;
  }
  return tks_d0_;
}

std::vector<float>* const & Baby::tks_dz() const{
  if(!c_tks_dz_ && b_tks_dz_){
    b_tks_dz_->GetEntry(entry_);
    c_tks_dz_ = true;
  }
  return tks_dz_;
}

std::vector<float>* const & Baby::tks_eta() const{
  if(!c_tks_eta_ && b_tks_eta_){
    b_tks_eta_->GetEntry(entry_);
    c_tks_eta_ = true;
  }
  return tks_eta_;
}

std::vector<float>* const & Baby::tks_miniso() const{
  if(!c_tks_miniso_ && b_tks_miniso_){
    b_tks_miniso_->GetEntry(entry_);
    c_tks_miniso_ = true;
  }
  return tks_miniso_;
}

std::vector<float>* const & Baby::tks_mt() const{
  if(!c_tks_mt_ && b_tks_mt_){
    b_tks_mt_->GetEntry(entry_);
    c_tks_mt_ = true;
  }
  return tks_mt_;
}

std::vector<float>* const & Baby::tks_mt2() const{
  if(!c_tks_mt2_ && b_tks_mt2_){
    b_tks_mt2_->GetEntry(entry_);
    c_tks_mt2_ = true;
  }
  return tks_mt2_;
}

std::vector<int>* const & Baby::tks_pdg() const{
  if(!c_tks_pdg_ && b_tks_pdg_){
    b_tks_pdg_->GetEntry(entry_);
    c_tks_pdg_ = true;
  }
  return tks_pdg_;
}

std::vector<float>* const & Baby::tks_phi() const{
  if(!c_tks_phi_ && b_tks_phi_){
    b_tks_phi_->GetEntry(entry_);
    c_tks_phi_ = true;
  }
  return tks_phi_;
}

std::vector<float>* const & Baby::tks_pt() const{
  if(!c_tks_pt_ && b_tks_pt_){
    b_tks_pt_->GetEntry(entry_);
    c_tks_pt_ = true;
  }
  return tks_pt_;
}

std::vector<float>* const & Baby::tks_reliso() const{
  if(!c_tks_reliso_ && b_tks_reliso_){
    b_tks_reliso_->GetEntry(entry_);
    c_tks_reliso_ = true;
  }
  return tks_reliso_;
}

std::vector<bool>* const & Baby::tks_tm() const{
  if(!c_tks_tm_ && b_tks_tm_){
    b_tks_tm_->GetEntry(entry_);
    c_tks_tm_ = true;
  }
  return tks_tm_;
}

std::vector<bool>* const & Baby::trig() const{
  if(!c_trig_ && b_trig_){
    b_trig_->GetEntry(entry_);
    c_trig_ = true;
  }
  return trig_;
}

bool const & Baby::trig_lep() const{
  if(!c_trig_lep_ && b_trig_lep_){
    b_trig_lep_->GetEntry(entry_);
    c_trig_lep_ = true;
  }
  return trig_lep_;
}

bool const & Baby::trig_met() const{
  if(!c_trig_met_ && b_trig_met_){
    b_trig_met_->GetEntry(entry_);
    c_trig_met_ = true;
  }
  return trig_met_;
}

std::vector<float>* const & Baby::trig_prescale() const{
  if(!c_trig_prescale_ && b_trig_prescale_){
    b_trig_prescale_->GetEntry(entry_);
    c_trig_prescale_ = true;
  }
  return trig_prescale_;
}

bool const & Baby::trig_ra4() const{
  if(!c_trig_ra4_ && b_trig_ra4_){
    b_trig_ra4_->GetEntry(entry_);
    c_trig_ra4_ = true;
  }
  return trig_ra4_;
}

bool const & Baby::trig_vvvl() const{
  if(!c_trig_vvvl_ && b_trig_vvvl_){
    b_trig_vvvl_->GetEntry(entry_);
    c_trig_vvvl_ = true;
  }
  return trig_vvvl_;
}

int const & Baby::type() const{
  if(!c_type_ && b_type_){
    b_type_->GetEntry(entry_);
    c_type_ = true;
  }
  return type_;
}

float const & Baby::w_btag() const{
  if(!c_w_btag_ && b_w_btag_){
    b_w_btag_->GetEntry(entry_);
    c_w_btag_ = true;
  }
  return w_btag_;
}

float const & Baby::w_btag40() const{
  if(!c_w_btag40_ && b_w_btag40_){
    b_w_btag40_->GetEntry(entry_);
    c_w_btag40_ = true;
  }
  return w_btag40_;
}

float const & Baby::w_btag_loose() const{
  if(!c_w_btag_loose_ && b_w_btag_loose_){
    b_w_btag_loose_->GetEntry(entry_);
    c_w_btag_loose_ = true;
  }
  return w_btag_loose_;
}

float const & Baby::w_fs_lep() const{
  if(!c_w_fs_lep_ && b_w_fs_lep_){
    b_w_fs_lep_->GetEntry(entry_);
    c_w_fs_lep_ = true;
  }
  return w_fs_lep_;
}

float const & Baby::w_isr() const{
  if(!c_w_isr_ && b_w_isr_){
    b_w_isr_->GetEntry(entry_);
    c_w_isr_ = true;
  }
  return w_isr_;
}

float const & Baby::w_lep() const{
  if(!c_w_lep_ && b_w_lep_){
    b_w_lep_->GetEntry(entry_);
    c_w_lep_ = true;
  }
  return w_lep_;
}

float const & Baby::w_lumi() const{
  if(!c_w_lumi_ && b_w_lumi_){
    b_w_lumi_->GetEntry(entry_);
    c_w_lumi_ = true;
  }
  return w_lumi_;
}

float const & Baby::w_pu() const{
  if(!c_w_pu_ && b_w_pu_){
    b_w_pu_->GetEntry(entry_);
    c_w_pu_ = true;
  }
  return w_pu_;
}

float const & Baby::w_toppt() const{
  if(!c_w_toppt_ && b_w_toppt_){
    b_w_toppt_->GetEntry(entry_);
    c_w_toppt_ = true;
  }
  return w_toppt_;
}

float const & Baby::weight() const{
  if(!c_weight_ && b_weight_){
    b_weight_->GetEntry(entry_);
    c_weight_ = true;
  }
  return weight_;
}

float const & Baby::weight_rpv() const{
  if(!c_weight_rpv_ && b_weight_rpv_){
    b_weight_rpv_->GetEntry(entry_);
    c_weight_rpv_ = true;
  }
  return weight_rpv_;
}