baby_base.hh

Go to the documentation of this file.

// baby_base: base class to handle reduced tree ntuples
// File generated with generate_baby.exe

#ifndef H_BABY_BASE
#define H_BABY_BASE

#include <vector>
#include <string>

#include "TTree.h"
#include "TChain.h"

class baby_base{
public:
  baby_base(); // Constructor to create tree
  baby_base(const std::string &filename); // Constructor to read tree

  int Add(const std::string &filename);
  long GetEntries() const;
  virtual void GetEntry(const long entry);
  bool PassString(TString cut);

  virtual void Clear();
  virtual void Fill();
  void Write();

  virtual std::string BabyType() const;

  static const double bad_val_;

  virtual ~baby_base();

  Long64_t  const & event() const;
  Long64_t  & event();
  bool  const & fromGS() const;
  bool  & fromGS();
  bool  const & jetmismeas() const;
  bool  & jetmismeas();
  bool  const & json12p9() const;
  bool  & json12p9();
  bool  const & json4p0() const;
  bool  & json4p0();
  bool  const & low_dphi() const;
  bool  & low_dphi();
  bool  const & pass() const;
  bool  & pass();
  bool  const & pass_badcalib() const;
  bool  & pass_badcalib();
  bool  const & pass_badchhad() const;
  bool  & pass_badchhad();
  bool  const & pass_badpfmu() const;
  bool  & pass_badpfmu();
  bool  const & pass_cschalo() const;
  bool  & pass_cschalo();
  bool  const & pass_ecaldeadcell() const;
  bool  & pass_ecaldeadcell();
  bool  const & pass_eebadsc() const;
  bool  & pass_eebadsc();
  bool  const & pass_fsjets() const;
  bool  & pass_fsjets();
  bool  const & pass_fsmet() const;
  bool  & pass_fsmet();
  bool  const & pass_goodv() const;
  bool  & pass_goodv();
  bool  const & pass_hbhe() const;
  bool  & pass_hbhe();
  bool  const & pass_hbheiso() const;
  bool  & pass_hbheiso();
  bool  const & pass_jets() const;
  bool  & pass_jets();
  bool  const & pass_jets_nohf() const;
  bool  & pass_jets_nohf();
  bool  const & pass_jets_ra2() const;
  bool  & pass_jets_ra2();
  bool  const & pass_jets_tight() const;
  bool  & pass_jets_tight();
  bool  const & pass_jets_tight_ra2() const;
  bool  & pass_jets_tight_ra2();
  bool  const & pass_nohf() const;
  bool  & pass_nohf();
  bool  const & pass_ra2() const;
  bool  & pass_ra2();
  bool  const & pass_ra2_badmu() const;
  bool  & pass_ra2_badmu();
  bool  const & stitch() const;
  bool  & stitch();
  bool  const & stitch_ht() const;
  bool  & stitch_ht();
  bool  const & stitch_met() const;
  bool  & stitch_met();
  bool  const & trig_lep() const;
  bool  & trig_lep();
  bool  const & trig_met() const;
  bool  & trig_met();
  bool  const & trig_ra4() const;
  bool  & trig_ra4();
  bool  const & trig_vvvl() const;
  bool  & trig_vvvl();
  float  const & antitop_pt() const;
  float  & antitop_pt();
  float  const & dphi1() const;
  float  & dphi1();
  float  const & dphi2() const;
  float  & dphi2();
  float  const & dphi3() const;
  float  & dphi3();
  float  const & dphi4() const;
  float  & dphi4();
  float  const & dphi_wlep() const;
  float  & dphi_wlep();
  float  const & eff_jetid() const;
  float  & eff_jetid();
  float  const & eff_trig() const;
  float  & eff_trig();
  float  const & elel_eta() const;
  float  & elel_eta();
  float  const & elel_m() const;
  float  & elel_m();
  float  const & elel_phi() const;
  float  & elel_phi();
  float  const & elel_pt() const;
  float  & elel_pt();
  float  const & elel_pt1() const;
  float  & elel_pt1();
  float  const & elel_pt2() const;
  float  & elel_pt2();
  float  const & elel_w() const;
  float  & elel_w();
  float  const & elelv_eta() const;
  float  & elelv_eta();
  float  const & elelv_m() const;
  float  & elelv_m();
  float  const & elelv_phi() const;
  float  & elelv_phi();
  float  const & elelv_pt() const;
  float  & elelv_pt();
  float  const & elelv_pt1() const;
  float  & elelv_pt1();
  float  const & elelv_pt2() const;
  float  & elelv_pt2();
  float  const & elelv_w() const;
  float  & elelv_w();
  float  const & elmu_eta() const;
  float  & elmu_eta();
  float  const & elmu_m() const;
  float  & elmu_m();
  float  const & elmu_phi() const;
  float  & elmu_phi();
  float  const & elmu_pt() const;
  float  & elmu_pt();
  float  const & elmu_pt1() const;
  float  & elmu_pt1();
  float  const & elmu_pt2() const;
  float  & elmu_pt2();
  float  const & elmu_w() const;
  float  & elmu_w();
  float  const & hig_am() const;
  float  & hig_am();
  float  const & hig_dm() const;
  float  & hig_dm();
  float  const & hig_drmax() const;
  float  & hig_drmax();
  float  const & higd_am() const;
  float  & higd_am();
  float  const & higd_dm() const;
  float  & higd_dm();
  float  const & higd_drmax() const;
  float  & higd_drmax();
  float  const & ht() const;
  float  & ht();
  float  const & ht_clean() const;
  float  & ht_clean();
  float  const & ht_hlt() const;
  float  & ht_hlt();
  float  const & ht_isr_me() const;
  float  & ht_isr_me();
  float  const & ht_ra2() const;
  float  & ht_ra2();
  float  const & ht_tru() const;
  float  & ht_tru();
  float  const & isr_tru_eta() const;
  float  & isr_tru_eta();
  float  const & isr_tru_phi() const;
  float  & isr_tru_phi();
  float  const & isr_tru_pt() const;
  float  & isr_tru_pt();
  float  const & jetsys_eta() const;
  float  & jetsys_eta();
  float  const & jetsys_m() const;
  float  & jetsys_m();
  float  const & jetsys_nob_eta() const;
  float  & jetsys_nob_eta();
  float  const & jetsys_nob_m() const;
  float  & jetsys_nob_m();
  float  const & jetsys_nob_phi() const;
  float  & jetsys_nob_phi();
  float  const & jetsys_nob_pt() const;
  float  & jetsys_nob_pt();
  float  const & jetsys_nobd_eta() const;
  float  & jetsys_nobd_eta();
  float  const & jetsys_nobd_m() const;
  float  & jetsys_nobd_m();
  float  const & jetsys_nobd_phi() const;
  float  & jetsys_nobd_phi();
  float  const & jetsys_nobd_pt() const;
  float  & jetsys_nobd_pt();
  float  const & jetsys_phi() const;
  float  & jetsys_phi();
  float  const & jetsys_pt() const;
  float  & jetsys_pt();
  float  const & m_tt() const;
  float  & m_tt();
  float  const & mct() const;
  float  & mct();
  float  const & mctd() const;
  float  & mctd();
  float  const & met() const;
  float  & met();
  float  const & met_calo() const;
  float  & met_calo();
  float  const & met_calo_phi() const;
  float  & met_calo_phi();
  float  const & met_mini() const;
  float  & met_mini();
  float  const & met_mini_phi() const;
  float  & met_mini_phi();
  float  const & met_nohf() const;
  float  & met_nohf();
  float  const & met_nohf_phi() const;
  float  & met_nohf_phi();
  float  const & met_phi() const;
  float  & met_phi();
  float  const & met_phi_puppi() const;
  float  & met_phi_puppi();
  float  const & met_puppi() const;
  float  & met_puppi();
  float  const & met_raw() const;
  float  & met_raw();
  float  const & met_raw_phi() const;
  float  & met_raw_phi();
  float  const & met_rebal() const;
  float  & met_rebal();
  float  const & met_tru() const;
  float  & met_tru();
  float  const & met_tru_nuw() const;
  float  & met_tru_nuw();
  float  const & met_tru_nuw_phi() const;
  float  & met_tru_nuw_phi();
  float  const & met_tru_phi() const;
  float  & met_tru_phi();
  float  const & mht() const;
  float  & mht();
  float  const & mht_clean() const;
  float  & mht_clean();
  float  const & mht_clean_phi() const;
  float  & mht_clean_phi();
  float  const & mht_phi() const;
  float  & mht_phi();
  float  const & mj08() const;
  float  & mj08();
  float  const & mj12() const;
  float  & mj12();
  float  const & mj14() const;
  float  & mj14();
  float  const & mj14_nolep() const;
  float  & mj14_nolep();
  float  const & mt() const;
  float  & mt();
  float  const & mt2() const;
  float  & mt2();
  float  const & mt2_0mass() const;
  float  & mt2_0mass();
  float  const & mt_nohf() const;
  float  & mt_nohf();
  float  const & mt_rebal() const;
  float  & mt_rebal();
  float  const & mt_tru() const;
  float  & mt_tru();
  float  const & mt_tru_nuw() const;
  float  & mt_tru_nuw();
  float  const & mumu_eta() const;
  float  & mumu_eta();
  float  const & mumu_m() const;
  float  & mumu_m();
  float  const & mumu_phi() const;
  float  & mumu_phi();
  float  const & mumu_pt() const;
  float  & mumu_pt();
  float  const & mumu_pt1() const;
  float  & mumu_pt1();
  float  const & mumu_pt2() const;
  float  & mumu_pt2();
  float  const & mumu_w() const;
  float  & mumu_w();
  float  const & mumuv_eta() const;
  float  & mumuv_eta();
  float  const & mumuv_m() const;
  float  & mumuv_m();
  float  const & mumuv_phi() const;
  float  & mumuv_phi();
  float  const & mumuv_pt() const;
  float  & mumuv_pt();
  float  const & mumuv_pt1() const;
  float  & mumuv_pt1();
  float  const & mumuv_pt2() const;
  float  & mumuv_pt2();
  float  const & mumuv_w() const;
  float  & mumuv_w();
  float  const & nisr() const;
  float  & nisr();
  float  const & ntrupv_mean() const;
  float  & ntrupv_mean();
  float  const & onel_ele105() const;
  float  & onel_ele105();
  float  const & onel_ele23() const;
  float  & onel_ele23();
  float  const & onel_ele8() const;
  float  & onel_ele8();
  float  const & onel_vvvl() const;
  float  & onel_vvvl();
  float  const & onht() const;
  float  & onht();
  float  const & onmet() const;
  float  & onmet();
  float  const & onmu_isomu18() const;
  float  & onmu_isomu18();
  float  const & onmu_mu50() const;
  float  & onmu_mu50();
  float  const & onmu_mu8() const;
  float  & onmu_mu8();
  float  const & onmu_vvvl() const;
  float  & onmu_vvvl();
  float  const & onph_ph90() const;
  float  & onph_ph90();
  float  const & ptll_me() const;
  float  & ptll_me();
  float  const & st() const;
  float  & st();
  float  const & top_pt() const;
  float  & top_pt();
  float  const & w_bhig() const;
  float  & w_bhig();
  float  const & w_bhig_deep() const;
  float  & w_bhig_deep();
  float  const & w_bhig_deep_proc() const;
  float  & w_bhig_deep_proc();
  float  const & w_bhig_proc() const;
  float  & w_bhig_proc();
  float  const & w_btag() const;
  float  & w_btag();
  float  const & w_btag_deep() const;
  float  & w_btag_deep();
  float  const & w_btag_deep_proc() const;
  float  & w_btag_deep_proc();
  float  const & w_btag_loose() const;
  float  & w_btag_loose();
  float  const & w_btag_loose_deep() const;
  float  & w_btag_loose_deep();
  float  const & w_btag_loose_deep_proc() const;
  float  & w_btag_loose_deep_proc();
  float  const & w_btag_loose_proc() const;
  float  & w_btag_loose_proc();
  float  const & w_btag_proc() const;
  float  & w_btag_proc();
  float  const & w_btag_tight() const;
  float  & w_btag_tight();
  float  const & w_btag_tight_deep() const;
  float  & w_btag_tight_deep();
  float  const & w_btag_tight_deep_proc() const;
  float  & w_btag_tight_deep_proc();
  float  const & w_btag_tight_proc() const;
  float  & w_btag_tight_proc();
  float  const & w_fs_lep() const;
  float  & w_fs_lep();
  float  const & w_isr() const;
  float  & w_isr();
  float  const & w_lep() const;
  float  & w_lep();
  float  const & w_lumi() const;
  float  & w_lumi();
  float  const & w_pu() const;
  float  & w_pu();
  float  const & w_toppt() const;
  float  & w_toppt();
  float  const & weight() const;
  float  & weight();
  float  const & weight_rpv() const;
  float  & weight_rpv();
  int  const & bb_highcsv_idx() const;
  int  & bb_highcsv_idx();
  int  const & bb_highcsv_idx_deep() const;
  int  & bb_highcsv_idx_deep();
  int  const & hig_bin() const;
  int  & hig_bin();
  int  const & higd_bin() const;
  int  & higd_bin();
  int  const & lumiblock() const;
  int  & lumiblock();
  int  const & mgluino() const;
  int  & mgluino();
  int  const & mlsp() const;
  int  & mlsp();
  int  const & nbdfl() const;
  int  & nbdfl();
  int  const & nbdfm() const;
  int  & nbdfm();
  int  const & nbdft() const;
  int  & nbdft();
  int  const & nbdl() const;
  int  & nbdl();
  int  const & nbdm() const;
  int  & nbdm();
  int  const & nbdt() const;
  int  & nbdt();
  int  const & nbl() const;
  int  & nbl();
  int  const & nbm() const;
  int  & nbm();
  int  const & nbm_ra2() const;
  int  & nbm_ra2();
  int  const & nbt() const;
  int  & nbt();
  int  const & nels() const;
  int  & nels();
  int  const & nels_ele23() const;
  int  & nels_ele23();
  int  const & nels_vvvl() const;
  int  & nels_vvvl();
  int  const & nfjets08() const;
  int  & nfjets08();
  int  const & nfjets14() const;
  int  & nfjets14();
  int  const & nisr_me() const;
  int  & nisr_me();
  int  const & njets() const;
  int  & njets();
  int  const & njets_clean() const;
  int  & njets_clean();
  int  const & njets_ra2() const;
  int  & njets_ra2();
  int  const & nleps() const;
  int  & nleps();
  int  const & nleps_tm() const;
  int  & nleps_tm();
  int  const & nmus() const;
  int  & nmus();
  int  const & nmus_isomu18() const;
  int  & nmus_isomu18();
  int  const & nmus_vvvl() const;
  int  & nmus_vvvl();
  int  const & nph() const;
  int  & nph();
  int  const & npv() const;
  int  & npv();
  int  const & ntks() const;
  int  & ntks();
  int  const & ntruels() const;
  int  & ntruels();
  int  const & ntruleps() const;
  int  & ntruleps();
  int  const & ntrumus() const;
  int  & ntrumus();
  int  const & ntrupv() const;
  int  & ntrupv();
  int  const & ntrutaush() const;
  int  & ntrutaush();
  int  const & ntrutausl() const;
  int  & ntrutausl();
  int  const & nvels() const;
  int  & nvels();
  int  const & nveto() const;
  int  & nveto();
  int  const & nvleps() const;
  int  & nvleps();
  int  const & nvmus() const;
  int  & nvmus();
  int  const & run() const;
  int  & run();
  int  const & type() const;
  int  & type();
  std::vector<bool>  const & els_ele105() const;
  std::vector<bool>  & els_ele105();
  std::vector<bool>  const & els_ele23() const;
  std::vector<bool>  & els_ele23();
  std::vector<bool>  const & els_ele8() const;
  std::vector<bool>  & els_ele8();
  std::vector<bool>  const & els_inz() const;
  std::vector<bool>  & els_inz();
  std::vector<bool>  const & els_inzv() const;
  std::vector<bool>  & els_inzv();
  std::vector<bool>  const & els_ispf() const;
  std::vector<bool>  & els_ispf();
  std::vector<bool>  const & els_sig() const;
  std::vector<bool>  & els_sig();
  std::vector<bool>  const & els_sigid() const;
  std::vector<bool>  & els_sigid();
  std::vector<bool>  const & els_tight() const;
  std::vector<bool>  & els_tight();
  std::vector<bool>  const & els_tm() const;
  std::vector<bool>  & els_tm();
  std::vector<bool>  const & els_vvvl() const;
  std::vector<bool>  & els_vvvl();
  std::vector<bool>  const & jets_h1() const;
  std::vector<bool>  & jets_h1();
  std::vector<bool>  const & jets_h1d() const;
  std::vector<bool>  & jets_h1d();
  std::vector<bool>  const & jets_h2() const;
  std::vector<bool>  & jets_h2();
  std::vector<bool>  const & jets_h2d() const;
  std::vector<bool>  & jets_h2d();
  std::vector<bool>  const & jets_isisr() const;
  std::vector<bool>  & jets_isisr();
  std::vector<bool>  const & jets_islep() const;
  std::vector<bool>  & jets_islep();
  std::vector<bool>  const & mc_gs() const;
  std::vector<bool>  & mc_gs();
  std::vector<bool>  const & mus_bad() const;
  std::vector<bool>  & mus_bad();
  std::vector<bool>  const & mus_bad_dupl() const;
  std::vector<bool>  & mus_bad_dupl();
  std::vector<bool>  const & mus_bad_trkmu() const;
  std::vector<bool>  & mus_bad_trkmu();
  std::vector<bool>  const & mus_demoted() const;
  std::vector<bool>  & mus_demoted();
  std::vector<bool>  const & mus_inz() const;
  std::vector<bool>  & mus_inz();
  std::vector<bool>  const & mus_inzv() const;
  std::vector<bool>  & mus_inzv();
  std::vector<bool>  const & mus_isomu18() const;
  std::vector<bool>  & mus_isomu18();
  std::vector<bool>  const & mus_mu50() const;
  std::vector<bool>  & mus_mu50();
  std::vector<bool>  const & mus_mu8() const;
  std::vector<bool>  & mus_mu8();
  std::vector<bool>  const & mus_sig() const;
  std::vector<bool>  & mus_sig();
  std::vector<bool>  const & mus_sigid() const;
  std::vector<bool>  & mus_sigid();
  std::vector<bool>  const & mus_tight() const;
  std::vector<bool>  & mus_tight();
  std::vector<bool>  const & mus_tm() const;
  std::vector<bool>  & mus_tm();
  std::vector<bool>  const & mus_trk_quality() const;
  std::vector<bool>  & mus_trk_quality();
  std::vector<bool>  const & mus_vvvl() const;
  std::vector<bool>  & mus_vvvl();
  std::vector<bool>  const & ph_ph90() const;
  std::vector<bool>  & ph_ph90();
  std::vector<bool>  const & ph_tm() const;
  std::vector<bool>  & ph_tm();
  std::vector<bool>  const & sys_pass() const;
  std::vector<bool>  & sys_pass();
  std::vector<bool>  const & tks_tm() const;
  std::vector<bool>  & tks_tm();
  std::vector<bool>  const & trig() const;
  std::vector<bool>  & trig();
  std::vector<float>  const & bb_m() const;
  std::vector<float>  & bb_m();
  std::vector<float>  const & bb_m_deep() const;
  std::vector<float>  & bb_m_deep();
  std::vector<float>  const & bb_pt() const;
  std::vector<float>  & bb_pt();
  std::vector<float>  const & bb_pt_deep() const;
  std::vector<float>  & bb_pt_deep();
  std::vector<float>  const & dr_bb() const;
  std::vector<float>  & dr_bb();
  std::vector<float>  const & dr_bb_deep() const;
  std::vector<float>  & dr_bb_deep();
  std::vector<float>  const & els_d0() const;
  std::vector<float>  & els_d0();
  std::vector<float>  const & els_deta_sctrk() const;
  std::vector<float>  & els_deta_sctrk();
  std::vector<float>  const & els_dphi_sctrk() const;
  std::vector<float>  & els_dphi_sctrk();
  std::vector<float>  const & els_dz() const;
  std::vector<float>  & els_dz();
  std::vector<float>  const & els_em_e() const;
  std::vector<float>  & els_em_e();
  std::vector<float>  const & els_eoverp() const;
  std::vector<float>  & els_eoverp();
  std::vector<float>  const & els_eta() const;
  std::vector<float>  & els_eta();
  std::vector<float>  const & els_hovere() const;
  std::vector<float>  & els_hovere();
  std::vector<float>  const & els_ip3d() const;
  std::vector<float>  & els_ip3d();
  std::vector<float>  const & els_miniso() const;
  std::vector<float>  & els_miniso();
  std::vector<float>  const & els_phi() const;
  std::vector<float>  & els_phi();
  std::vector<float>  const & els_pt() const;
  std::vector<float>  & els_pt();
  std::vector<float>  const & els_reliso() const;
  std::vector<float>  & els_reliso();
  std::vector<float>  const & els_sceta() const;
  std::vector<float>  & els_sceta();
  std::vector<float>  const & els_scpt() const;
  std::vector<float>  & els_scpt();
  std::vector<float>  const & els_trk_pt() const;
  std::vector<float>  & els_trk_pt();
  std::vector<float>  const & els_trk_pterr() const;
  std::vector<float>  & els_trk_pterr();
  std::vector<float>  const & els_vvvl_eta() const;
  std::vector<float>  & els_vvvl_eta();
  std::vector<float>  const & els_vvvl_phi() const;
  std::vector<float>  & els_vvvl_phi();
  std::vector<float>  const & els_vvvl_pt() const;
  std::vector<float>  & els_vvvl_pt();
  std::vector<float>  const & fjets08_eta() const;
  std::vector<float>  & fjets08_eta();
  std::vector<float>  const & fjets08_m() const;
  std::vector<float>  & fjets08_m();
  std::vector<float>  const & fjets08_phi() const;
  std::vector<float>  & fjets08_phi();
  std::vector<float>  const & fjets08_pt() const;
  std::vector<float>  & fjets08_pt();
  std::vector<float>  const & fjets14_eta() const;
  std::vector<float>  & fjets14_eta();
  std::vector<float>  const & fjets14_m() const;
  std::vector<float>  & fjets14_m();
  std::vector<float>  const & fjets14_phi() const;
  std::vector<float>  & fjets14_phi();
  std::vector<float>  const & fjets14_pt() const;
  std::vector<float>  & fjets14_pt();
  std::vector<float>  const & jets_csv() const;
  std::vector<float>  & jets_csv();
  std::vector<float>  const & jets_csvd() const;
  std::vector<float>  & jets_csvd();
  std::vector<float>  const & jets_csvdf() const;
  std::vector<float>  & jets_csvdf();
  std::vector<float>  const & jets_eta() const;
  std::vector<float>  & jets_eta();
  std::vector<float>  const & jets_gen_pt() const;
  std::vector<float>  & jets_gen_pt();
  std::vector<float>  const & jets_m() const;
  std::vector<float>  & jets_m();
  std::vector<float>  const & jets_phi() const;
  std::vector<float>  & jets_phi();
  std::vector<float>  const & jets_pt() const;
  std::vector<float>  & jets_pt();
  std::vector<float>  const & leps_eta() const;
  std::vector<float>  & leps_eta();
  std::vector<float>  const & leps_id() const;
  std::vector<float>  & leps_id();
  std::vector<float>  const & leps_phi() const;
  std::vector<float>  & leps_phi();
  std::vector<float>  const & leps_pt() const;
  std::vector<float>  & leps_pt();
  std::vector<float>  const & mc_eta() const;
  std::vector<float>  & mc_eta();
  std::vector<float>  const & mc_gs_dau_dr() const;
  std::vector<float>  & mc_gs_dau_dr();
  std::vector<float>  const & mc_mass() const;
  std::vector<float>  & mc_mass();
  std::vector<float>  const & mc_phi() const;
  std::vector<float>  & mc_phi();
  std::vector<float>  const & mc_pt() const;
  std::vector<float>  & mc_pt();
  std::vector<float>  const & mus_d0() const;
  std::vector<float>  & mus_d0();
  std::vector<float>  const & mus_dz() const;
  std::vector<float>  & mus_dz();
  std::vector<float>  const & mus_em_e() const;
  std::vector<float>  & mus_em_e();
  std::vector<float>  const & mus_eta() const;
  std::vector<float>  & mus_eta();
  std::vector<float>  const & mus_had_e() const;
  std::vector<float>  & mus_had_e();
  std::vector<float>  const & mus_miniso() const;
  std::vector<float>  & mus_miniso();
  std::vector<float>  const & mus_phi() const;
  std::vector<float>  & mus_phi();
  std::vector<float>  const & mus_pt() const;
  std::vector<float>  & mus_pt();
  std::vector<float>  const & mus_pterr() const;
  std::vector<float>  & mus_pterr();
  std::vector<float>  const & mus_reliso() const;
  std::vector<float>  & mus_reliso();
  std::vector<float>  const & mus_vvvl_eta() const;
  std::vector<float>  & mus_vvvl_eta();
  std::vector<float>  const & mus_vvvl_phi() const;
  std::vector<float>  & mus_vvvl_phi();
  std::vector<float>  const & mus_vvvl_pt() const;
  std::vector<float>  & mus_vvvl_pt();
  std::vector<float>  const & ph_eta() const;
  std::vector<float>  & ph_eta();
  std::vector<float>  const & ph_phi() const;
  std::vector<float>  & ph_phi();
  std::vector<float>  const & ph_pt() const;
  std::vector<float>  & ph_pt();
  std::vector<float>  const & sys_bchig() const;
  std::vector<float>  & sys_bchig();
  std::vector<float>  const & sys_bchig_deep() const;
  std::vector<float>  & sys_bchig_deep();
  std::vector<float>  const & sys_bchig_deep_proc() const;
  std::vector<float>  & sys_bchig_deep_proc();
  std::vector<float>  const & sys_bchig_proc() const;
  std::vector<float>  & sys_bchig_proc();
  std::vector<float>  const & sys_bctag() const;
  std::vector<float>  & sys_bctag();
  std::vector<float>  const & sys_bctag_deep() const;
  std::vector<float>  & sys_bctag_deep();
  std::vector<float>  const & sys_bctag_deep_proc() const;
  std::vector<float>  & sys_bctag_deep_proc();
  std::vector<float>  const & sys_bctag_loose() const;
  std::vector<float>  & sys_bctag_loose();
  std::vector<float>  const & sys_bctag_loose_deep() const;
  std::vector<float>  & sys_bctag_loose_deep();
  std::vector<float>  const & sys_bctag_loose_deep_proc() const;
  std::vector<float>  & sys_bctag_loose_deep_proc();
  std::vector<float>  const & sys_bctag_loose_proc() const;
  std::vector<float>  & sys_bctag_loose_proc();
  std::vector<float>  const & sys_bctag_proc() const;
  std::vector<float>  & sys_bctag_proc();
  std::vector<float>  const & sys_bctag_tight() const;
  std::vector<float>  & sys_bctag_tight();
  std::vector<float>  const & sys_bctag_tight_deep() const;
  std::vector<float>  & sys_bctag_tight_deep();
  std::vector<float>  const & sys_bctag_tight_deep_proc() const;
  std::vector<float>  & sys_bctag_tight_deep_proc();
  std::vector<float>  const & sys_bctag_tight_proc() const;
  std::vector<float>  & sys_bctag_tight_proc();
  std::vector<float>  const & sys_fs_bchig() const;
  std::vector<float>  & sys_fs_bchig();
  std::vector<float>  const & sys_fs_bchig_deep() const;
  std::vector<float>  & sys_fs_bchig_deep();
  std::vector<float>  const & sys_fs_bctag() const;
  std::vector<float>  & sys_fs_bctag();
  std::vector<float>  const & sys_fs_bctag_deep() const;
  std::vector<float>  & sys_fs_bctag_deep();
  std::vector<float>  const & sys_fs_lep() const;
  std::vector<float>  & sys_fs_lep();
  std::vector<float>  const & sys_fs_udsghig() const;
  std::vector<float>  & sys_fs_udsghig();
  std::vector<float>  const & sys_fs_udsghig_deep() const;
  std::vector<float>  & sys_fs_udsghig_deep();
  std::vector<float>  const & sys_fs_udsgtag() const;
  std::vector<float>  & sys_fs_udsgtag();
  std::vector<float>  const & sys_fs_udsgtag_deep() const;
  std::vector<float>  & sys_fs_udsgtag_deep();
  std::vector<float>  const & sys_higd_am() const;
  std::vector<float>  & sys_higd_am();
  std::vector<float>  const & sys_higd_dm() const;
  std::vector<float>  & sys_higd_dm();
  std::vector<float>  const & sys_higd_drmax() const;
  std::vector<float>  & sys_higd_drmax();
  std::vector<float>  const & sys_ht() const;
  std::vector<float>  & sys_ht();
  std::vector<float>  const & sys_isr() const;
  std::vector<float>  & sys_isr();
  std::vector<float>  const & sys_lep() const;
  std::vector<float>  & sys_lep();
  std::vector<float>  const & sys_met() const;
  std::vector<float>  & sys_met();
  std::vector<float>  const & sys_mj12() const;
  std::vector<float>  & sys_mj12();
  std::vector<float>  const & sys_mj14() const;
  std::vector<float>  & sys_mj14();
  std::vector<float>  const & sys_mj14_nolep() const;
  std::vector<float>  & sys_mj14_nolep();
  std::vector<float>  const & sys_mt() const;
  std::vector<float>  & sys_mt();
  std::vector<float>  const & sys_muf() const;
  std::vector<float>  & sys_muf();
  std::vector<float>  const & sys_mur() const;
  std::vector<float>  & sys_mur();
  std::vector<float>  const & sys_murf() const;
  std::vector<float>  & sys_murf();
  std::vector<float>  const & sys_pdf() const;
  std::vector<float>  & sys_pdf();
  std::vector<float>  const & sys_pu() const;
  std::vector<float>  & sys_pu();
  std::vector<float>  const & sys_st() const;
  std::vector<float>  & sys_st();
  std::vector<float>  const & sys_trig() const;
  std::vector<float>  & sys_trig();
  std::vector<float>  const & sys_udsghig() const;
  std::vector<float>  & sys_udsghig();
  std::vector<float>  const & sys_udsghig_deep() const;
  std::vector<float>  & sys_udsghig_deep();
  std::vector<float>  const & sys_udsghig_deep_proc() const;
  std::vector<float>  & sys_udsghig_deep_proc();
  std::vector<float>  const & sys_udsghig_proc() const;
  std::vector<float>  & sys_udsghig_proc();
  std::vector<float>  const & sys_udsgtag() const;
  std::vector<float>  & sys_udsgtag();
  std::vector<float>  const & sys_udsgtag_deep() const;
  std::vector<float>  & sys_udsgtag_deep();
  std::vector<float>  const & sys_udsgtag_deep_proc() const;
  std::vector<float>  & sys_udsgtag_deep_proc();
  std::vector<float>  const & sys_udsgtag_loose() const;
  std::vector<float>  & sys_udsgtag_loose();
  std::vector<float>  const & sys_udsgtag_loose_deep() const;
  std::vector<float>  & sys_udsgtag_loose_deep();
  std::vector<float>  const & sys_udsgtag_loose_deep_proc() const;
  std::vector<float>  & sys_udsgtag_loose_deep_proc();
  std::vector<float>  const & sys_udsgtag_loose_proc() const;
  std::vector<float>  & sys_udsgtag_loose_proc();
  std::vector<float>  const & sys_udsgtag_proc() const;
  std::vector<float>  & sys_udsgtag_proc();
  std::vector<float>  const & sys_udsgtag_tight() const;
  std::vector<float>  & sys_udsgtag_tight();
  std::vector<float>  const & sys_udsgtag_tight_deep() const;
  std::vector<float>  & sys_udsgtag_tight_deep();
  std::vector<float>  const & sys_udsgtag_tight_deep_proc() const;
  std::vector<float>  & sys_udsgtag_tight_deep_proc();
  std::vector<float>  const & sys_udsgtag_tight_proc() const;
  std::vector<float>  & sys_udsgtag_tight_proc();
  std::vector<float>  const & tks_d0() const;
  std::vector<float>  & tks_d0();
  std::vector<float>  const & tks_dz() const;
  std::vector<float>  & tks_dz();
  std::vector<float>  const & tks_eta() const;
  std::vector<float>  & tks_eta();
  std::vector<float>  const & tks_miniso() const;
  std::vector<float>  & tks_miniso();
  std::vector<float>  const & tks_mt() const;
  std::vector<float>  & tks_mt();
  std::vector<float>  const & tks_mt2() const;
  std::vector<float>  & tks_mt2();
  std::vector<float>  const & tks_phi() const;
  std::vector<float>  & tks_phi();
  std::vector<float>  const & tks_pt() const;
  std::vector<float>  & tks_pt();
  std::vector<float>  const & tks_reliso() const;
  std::vector<float>  & tks_reliso();
  std::vector<float>  const & trig_prescale() const;
  std::vector<float>  & trig_prescale();
  std::vector<float>  const & w_pdf() const;
  std::vector<float>  & w_pdf();
  std::vector<int>  const & bb_gs_flavor() const;
  std::vector<int>  & bb_gs_flavor();
  std::vector<int>  const & bb_gs_flavor_deep() const;
  std::vector<int>  & bb_gs_flavor_deep();
  std::vector<int>  const & bb_gs_idx() const;
  std::vector<int>  & bb_gs_idx();
  std::vector<int>  const & bb_gs_idx_deep() const;
  std::vector<int>  & bb_gs_idx_deep();
  std::vector<int>  const & bb_jet_idx1() const;
  std::vector<int>  & bb_jet_idx1();
  std::vector<int>  const & bb_jet_idx1_deep() const;
  std::vector<int>  & bb_jet_idx1_deep();
  std::vector<int>  const & bb_jet_idx2() const;
  std::vector<int>  & bb_jet_idx2();
  std::vector<int>  const & bb_jet_idx2_deep() const;
  std::vector<int>  & bb_jet_idx2_deep();
  std::vector<int>  const & els_charge() const;
  std::vector<int>  & els_charge();
  std::vector<int>  const & els_trk_nholes() const;
  std::vector<int>  & els_trk_nholes();
  std::vector<int>  const & fjets08_nconst() const;
  std::vector<int>  & fjets08_nconst();
  std::vector<int>  const & fjets14_nconst() const;
  std::vector<int>  & fjets14_nconst();
  std::vector<int>  const & jets_fjet08_index() const;
  std::vector<int>  & jets_fjet08_index();
  std::vector<int>  const & jets_fjet12_index() const;
  std::vector<int>  & jets_fjet12_index();
  std::vector<int>  const & jets_fjet14_index() const;
  std::vector<int>  & jets_fjet14_index();
  std::vector<int>  const & jets_fjet14_nolep_index() const;
  std::vector<int>  & jets_fjet14_nolep_index();
  std::vector<int>  const & jets_gs_index() const;
  std::vector<int>  & jets_gs_index();
  std::vector<int>  const & jets_hflavor() const;
  std::vector<int>  & jets_hflavor();
  std::vector<int>  const & jets_ntrub() const;
  std::vector<int>  & jets_ntrub();
  std::vector<int>  const & jets_ntruc() const;
  std::vector<int>  & jets_ntruc();
  std::vector<int>  const & jets_pflavor() const;
  std::vector<int>  & jets_pflavor();
  std::vector<int>  const & mc_gs_dau_jetmatch() const;
  std::vector<int>  & mc_gs_dau_jetmatch();
  std::vector<int>  const & mc_id() const;
  std::vector<int>  & mc_id();
  std::vector<int>  const & mc_jetidx() const;
  std::vector<int>  & mc_jetidx();
  std::vector<int>  const & mc_mom() const;
  std::vector<int>  & mc_mom();
  std::vector<int>  const & mc_momidx() const;
  std::vector<int>  & mc_momidx();
  std::vector<int>  const & mc_num_dau() const;
  std::vector<int>  & mc_num_dau();
  std::vector<int>  const & mc_status() const;
  std::vector<int>  & mc_status();
  std::vector<int>  const & mus_charge() const;
  std::vector<int>  & mus_charge();
  std::vector<int>  const & mus_trk_algo() const;
  std::vector<int>  & mus_trk_algo();
  std::vector<int>  const & mus_trk_nholes_in() const;
  std::vector<int>  & mus_trk_nholes_in();
  std::vector<int>  const & mus_trk_nholes_out() const;
  std::vector<int>  & mus_trk_nholes_out();
  std::vector<int>  const & sys_nbdl() const;
  std::vector<int>  & sys_nbdl();
  std::vector<int>  const & sys_nbdm() const;
  std::vector<int>  & sys_nbdm();
  std::vector<int>  const & sys_nbdt() const;
  std::vector<int>  & sys_nbdt();
  std::vector<int>  const & sys_nbm() const;
  std::vector<int>  & sys_nbm();
  std::vector<int>  const & sys_njets() const;
  std::vector<int>  & sys_njets();
  std::vector<int>  const & tks_pdg() const;
  std::vector<int>  & tks_pdg();

  TChain chain_;
  TTree tree_;
  long entry_;

protected:
  const bool read_only_;

private:
  class VectorLoader{
  public:
    VectorLoader();
  private:
    static bool loaded_;
  };

  static VectorLoader vl_;
  Long64_t  event_;
  TBranch *b_event_;
  mutable bool c_event_;
  bool  fromGS_;
  TBranch *b_fromGS_;
  mutable bool c_fromGS_;
  bool  jetmismeas_;
  TBranch *b_jetmismeas_;
  mutable bool c_jetmismeas_;
  bool  json12p9_;
  TBranch *b_json12p9_;
  mutable bool c_json12p9_;
  bool  json4p0_;
  TBranch *b_json4p0_;
  mutable bool c_json4p0_;
  bool  low_dphi_;
  TBranch *b_low_dphi_;
  mutable bool c_low_dphi_;
  bool  pass_;
  TBranch *b_pass_;
  mutable bool c_pass_;
  bool  pass_badcalib_;
  TBranch *b_pass_badcalib_;
  mutable bool c_pass_badcalib_;
  bool  pass_badchhad_;
  TBranch *b_pass_badchhad_;
  mutable bool c_pass_badchhad_;
  bool  pass_badpfmu_;
  TBranch *b_pass_badpfmu_;
  mutable bool c_pass_badpfmu_;
  bool  pass_cschalo_;
  TBranch *b_pass_cschalo_;
  mutable bool c_pass_cschalo_;
  bool  pass_ecaldeadcell_;
  TBranch *b_pass_ecaldeadcell_;
  mutable bool c_pass_ecaldeadcell_;
  bool  pass_eebadsc_;
  TBranch *b_pass_eebadsc_;
  mutable bool c_pass_eebadsc_;
  bool  pass_fsjets_;
  TBranch *b_pass_fsjets_;
  mutable bool c_pass_fsjets_;
  bool  pass_fsmet_;
  TBranch *b_pass_fsmet_;
  mutable bool c_pass_fsmet_;
  bool  pass_goodv_;
  TBranch *b_pass_goodv_;
  mutable bool c_pass_goodv_;
  bool  pass_hbhe_;
  TBranch *b_pass_hbhe_;
  mutable bool c_pass_hbhe_;
  bool  pass_hbheiso_;
  TBranch *b_pass_hbheiso_;
  mutable bool c_pass_hbheiso_;
  bool  pass_jets_;
  TBranch *b_pass_jets_;
  mutable bool c_pass_jets_;
  bool  pass_jets_nohf_;
  TBranch *b_pass_jets_nohf_;
  mutable bool c_pass_jets_nohf_;
  bool  pass_jets_ra2_;
  TBranch *b_pass_jets_ra2_;
  mutable bool c_pass_jets_ra2_;
  bool  pass_jets_tight_;
  TBranch *b_pass_jets_tight_;
  mutable bool c_pass_jets_tight_;
  bool  pass_jets_tight_ra2_;
  TBranch *b_pass_jets_tight_ra2_;
  mutable bool c_pass_jets_tight_ra2_;
  bool  pass_nohf_;
  TBranch *b_pass_nohf_;
  mutable bool c_pass_nohf_;
  bool  pass_ra2_;
  TBranch *b_pass_ra2_;
  mutable bool c_pass_ra2_;
  bool  pass_ra2_badmu_;
  TBranch *b_pass_ra2_badmu_;
  mutable bool c_pass_ra2_badmu_;
  bool  stitch_;
  TBranch *b_stitch_;
  mutable bool c_stitch_;
  bool  stitch_ht_;
  TBranch *b_stitch_ht_;
  mutable bool c_stitch_ht_;
  bool  stitch_met_;
  TBranch *b_stitch_met_;
  mutable bool c_stitch_met_;
  bool  trig_lep_;
  TBranch *b_trig_lep_;
  mutable bool c_trig_lep_;
  bool  trig_met_;
  TBranch *b_trig_met_;
  mutable bool c_trig_met_;
  bool  trig_ra4_;
  TBranch *b_trig_ra4_;
  mutable bool c_trig_ra4_;
  bool  trig_vvvl_;
  TBranch *b_trig_vvvl_;
  mutable bool c_trig_vvvl_;
  float  antitop_pt_;
  TBranch *b_antitop_pt_;
  mutable bool c_antitop_pt_;
  float  dphi1_;
  TBranch *b_dphi1_;
  mutable bool c_dphi1_;
  float  dphi2_;
  TBranch *b_dphi2_;
  mutable bool c_dphi2_;
  float  dphi3_;
  TBranch *b_dphi3_;
  mutable bool c_dphi3_;
  float  dphi4_;
  TBranch *b_dphi4_;
  mutable bool c_dphi4_;
  float  dphi_wlep_;
  TBranch *b_dphi_wlep_;
  mutable bool c_dphi_wlep_;
  float  eff_jetid_;
  TBranch *b_eff_jetid_;
  mutable bool c_eff_jetid_;
  float  eff_trig_;
  TBranch *b_eff_trig_;
  mutable bool c_eff_trig_;
  float  elel_eta_;
  TBranch *b_elel_eta_;
  mutable bool c_elel_eta_;
  float  elel_m_;
  TBranch *b_elel_m_;
  mutable bool c_elel_m_;
  float  elel_phi_;
  TBranch *b_elel_phi_;
  mutable bool c_elel_phi_;
  float  elel_pt_;
  TBranch *b_elel_pt_;
  mutable bool c_elel_pt_;
  float  elel_pt1_;
  TBranch *b_elel_pt1_;
  mutable bool c_elel_pt1_;
  float  elel_pt2_;
  TBranch *b_elel_pt2_;
  mutable bool c_elel_pt2_;
  float  elel_w_;
  TBranch *b_elel_w_;
  mutable bool c_elel_w_;
  float  elelv_eta_;
  TBranch *b_elelv_eta_;
  mutable bool c_elelv_eta_;
  float  elelv_m_;
  TBranch *b_elelv_m_;
  mutable bool c_elelv_m_;
  float  elelv_phi_;
  TBranch *b_elelv_phi_;
  mutable bool c_elelv_phi_;
  float  elelv_pt_;
  TBranch *b_elelv_pt_;
  mutable bool c_elelv_pt_;
  float  elelv_pt1_;
  TBranch *b_elelv_pt1_;
  mutable bool c_elelv_pt1_;
  float  elelv_pt2_;
  TBranch *b_elelv_pt2_;
  mutable bool c_elelv_pt2_;
  float  elelv_w_;
  TBranch *b_elelv_w_;
  mutable bool c_elelv_w_;
  float  elmu_eta_;
  TBranch *b_elmu_eta_;
  mutable bool c_elmu_eta_;
  float  elmu_m_;
  TBranch *b_elmu_m_;
  mutable bool c_elmu_m_;
  float  elmu_phi_;
  TBranch *b_elmu_phi_;
  mutable bool c_elmu_phi_;
  float  elmu_pt_;
  TBranch *b_elmu_pt_;
  mutable bool c_elmu_pt_;
  float  elmu_pt1_;
  TBranch *b_elmu_pt1_;
  mutable bool c_elmu_pt1_;
  float  elmu_pt2_;
  TBranch *b_elmu_pt2_;
  mutable bool c_elmu_pt2_;
  float  elmu_w_;
  TBranch *b_elmu_w_;
  mutable bool c_elmu_w_;
  float  hig_am_;
  TBranch *b_hig_am_;
  mutable bool c_hig_am_;
  float  hig_dm_;
  TBranch *b_hig_dm_;
  mutable bool c_hig_dm_;
  float  hig_drmax_;
  TBranch *b_hig_drmax_;
  mutable bool c_hig_drmax_;
  float  higd_am_;
  TBranch *b_higd_am_;
  mutable bool c_higd_am_;
  float  higd_dm_;
  TBranch *b_higd_dm_;
  mutable bool c_higd_dm_;
  float  higd_drmax_;
  TBranch *b_higd_drmax_;
  mutable bool c_higd_drmax_;
  float  ht_;
  TBranch *b_ht_;
  mutable bool c_ht_;
  float  ht_clean_;
  TBranch *b_ht_clean_;
  mutable bool c_ht_clean_;
  float  ht_hlt_;
  TBranch *b_ht_hlt_;
  mutable bool c_ht_hlt_;
  float  ht_isr_me_;
  TBranch *b_ht_isr_me_;
  mutable bool c_ht_isr_me_;
  float  ht_ra2_;
  TBranch *b_ht_ra2_;
  mutable bool c_ht_ra2_;
  float  ht_tru_;
  TBranch *b_ht_tru_;
  mutable bool c_ht_tru_;
  float  isr_tru_eta_;
  TBranch *b_isr_tru_eta_;
  mutable bool c_isr_tru_eta_;
  float  isr_tru_phi_;
  TBranch *b_isr_tru_phi_;
  mutable bool c_isr_tru_phi_;
  float  isr_tru_pt_;
  TBranch *b_isr_tru_pt_;
  mutable bool c_isr_tru_pt_;
  float  jetsys_eta_;
  TBranch *b_jetsys_eta_;
  mutable bool c_jetsys_eta_;
  float  jetsys_m_;
  TBranch *b_jetsys_m_;
  mutable bool c_jetsys_m_;
  float  jetsys_nob_eta_;
  TBranch *b_jetsys_nob_eta_;
  mutable bool c_jetsys_nob_eta_;
  float  jetsys_nob_m_;
  TBranch *b_jetsys_nob_m_;
  mutable bool c_jetsys_nob_m_;
  float  jetsys_nob_phi_;
  TBranch *b_jetsys_nob_phi_;
  mutable bool c_jetsys_nob_phi_;
  float  jetsys_nob_pt_;
  TBranch *b_jetsys_nob_pt_;
  mutable bool c_jetsys_nob_pt_;
  float  jetsys_nobd_eta_;
  TBranch *b_jetsys_nobd_eta_;
  mutable bool c_jetsys_nobd_eta_;
  float  jetsys_nobd_m_;
  TBranch *b_jetsys_nobd_m_;
  mutable bool c_jetsys_nobd_m_;
  float  jetsys_nobd_phi_;
  TBranch *b_jetsys_nobd_phi_;
  mutable bool c_jetsys_nobd_phi_;
  float  jetsys_nobd_pt_;
  TBranch *b_jetsys_nobd_pt_;
  mutable bool c_jetsys_nobd_pt_;
  float  jetsys_phi_;
  TBranch *b_jetsys_phi_;
  mutable bool c_jetsys_phi_;
  float  jetsys_pt_;
  TBranch *b_jetsys_pt_;
  mutable bool c_jetsys_pt_;
  float  m_tt_;
  TBranch *b_m_tt_;
  mutable bool c_m_tt_;
  float  mct_;
  TBranch *b_mct_;
  mutable bool c_mct_;
  float  mctd_;
  TBranch *b_mctd_;
  mutable bool c_mctd_;
  float  met_;
  TBranch *b_met_;
  mutable bool c_met_;
  float  met_calo_;
  TBranch *b_met_calo_;
  mutable bool c_met_calo_;
  float  met_calo_phi_;
  TBranch *b_met_calo_phi_;
  mutable bool c_met_calo_phi_;
  float  met_mini_;
  TBranch *b_met_mini_;
  mutable bool c_met_mini_;
  float  met_mini_phi_;
  TBranch *b_met_mini_phi_;
  mutable bool c_met_mini_phi_;
  float  met_nohf_;
  TBranch *b_met_nohf_;
  mutable bool c_met_nohf_;
  float  met_nohf_phi_;
  TBranch *b_met_nohf_phi_;
  mutable bool c_met_nohf_phi_;
  float  met_phi_;
  TBranch *b_met_phi_;
  mutable bool c_met_phi_;
  float  met_phi_puppi_;
  TBranch *b_met_phi_puppi_;
  mutable bool c_met_phi_puppi_;
  float  met_puppi_;
  TBranch *b_met_puppi_;
  mutable bool c_met_puppi_;
  float  met_raw_;
  TBranch *b_met_raw_;
  mutable bool c_met_raw_;
  float  met_raw_phi_;
  TBranch *b_met_raw_phi_;
  mutable bool c_met_raw_phi_;
  float  met_rebal_;
  TBranch *b_met_rebal_;
  mutable bool c_met_rebal_;
  float  met_tru_;
  TBranch *b_met_tru_;
  mutable bool c_met_tru_;
  float  met_tru_nuw_;
  TBranch *b_met_tru_nuw_;
  mutable bool c_met_tru_nuw_;
  float  met_tru_nuw_phi_;
  TBranch *b_met_tru_nuw_phi_;
  mutable bool c_met_tru_nuw_phi_;
  float  met_tru_phi_;
  TBranch *b_met_tru_phi_;
  mutable bool c_met_tru_phi_;
  float  mht_;
  TBranch *b_mht_;
  mutable bool c_mht_;
  float  mht_clean_;
  TBranch *b_mht_clean_;
  mutable bool c_mht_clean_;
  float  mht_clean_phi_;
  TBranch *b_mht_clean_phi_;
  mutable bool c_mht_clean_phi_;
  float  mht_phi_;
  TBranch *b_mht_phi_;
  mutable bool c_mht_phi_;
  float  mj08_;
  TBranch *b_mj08_;
  mutable bool c_mj08_;
  float  mj12_;
  TBranch *b_mj12_;
  mutable bool c_mj12_;
  float  mj14_;
  TBranch *b_mj14_;
  mutable bool c_mj14_;
  float  mj14_nolep_;
  TBranch *b_mj14_nolep_;
  mutable bool c_mj14_nolep_;
  float  mt_;
  TBranch *b_mt_;
  mutable bool c_mt_;
  float  mt2_;
  TBranch *b_mt2_;
  mutable bool c_mt2_;
  float  mt2_0mass_;
  TBranch *b_mt2_0mass_;
  mutable bool c_mt2_0mass_;
  float  mt_nohf_;
  TBranch *b_mt_nohf_;
  mutable bool c_mt_nohf_;
  float  mt_rebal_;
  TBranch *b_mt_rebal_;
  mutable bool c_mt_rebal_;
  float  mt_tru_;
  TBranch *b_mt_tru_;
  mutable bool c_mt_tru_;
  float  mt_tru_nuw_;
  TBranch *b_mt_tru_nuw_;
  mutable bool c_mt_tru_nuw_;
  float  mumu_eta_;
  TBranch *b_mumu_eta_;
  mutable bool c_mumu_eta_;
  float  mumu_m_;
  TBranch *b_mumu_m_;
  mutable bool c_mumu_m_;
  float  mumu_phi_;
  TBranch *b_mumu_phi_;
  mutable bool c_mumu_phi_;
  float  mumu_pt_;
  TBranch *b_mumu_pt_;
  mutable bool c_mumu_pt_;
  float  mumu_pt1_;
  TBranch *b_mumu_pt1_;
  mutable bool c_mumu_pt1_;
  float  mumu_pt2_;
  TBranch *b_mumu_pt2_;
  mutable bool c_mumu_pt2_;
  float  mumu_w_;
  TBranch *b_mumu_w_;
  mutable bool c_mumu_w_;
  float  mumuv_eta_;
  TBranch *b_mumuv_eta_;
  mutable bool c_mumuv_eta_;
  float  mumuv_m_;
  TBranch *b_mumuv_m_;
  mutable bool c_mumuv_m_;
  float  mumuv_phi_;
  TBranch *b_mumuv_phi_;
  mutable bool c_mumuv_phi_;
  float  mumuv_pt_;
  TBranch *b_mumuv_pt_;
  mutable bool c_mumuv_pt_;
  float  mumuv_pt1_;
  TBranch *b_mumuv_pt1_;
  mutable bool c_mumuv_pt1_;
  float  mumuv_pt2_;
  TBranch *b_mumuv_pt2_;
  mutable bool c_mumuv_pt2_;
  float  mumuv_w_;
  TBranch *b_mumuv_w_;
  mutable bool c_mumuv_w_;
  float  nisr_;
  TBranch *b_nisr_;
  mutable bool c_nisr_;
  float  ntrupv_mean_;
  TBranch *b_ntrupv_mean_;
  mutable bool c_ntrupv_mean_;
  float  onel_ele105_;
  TBranch *b_onel_ele105_;
  mutable bool c_onel_ele105_;
  float  onel_ele23_;
  TBranch *b_onel_ele23_;
  mutable bool c_onel_ele23_;
  float  onel_ele8_;
  TBranch *b_onel_ele8_;
  mutable bool c_onel_ele8_;
  float  onel_vvvl_;
  TBranch *b_onel_vvvl_;
  mutable bool c_onel_vvvl_;
  float  onht_;
  TBranch *b_onht_;
  mutable bool c_onht_;
  float  onmet_;
  TBranch *b_onmet_;
  mutable bool c_onmet_;
  float  onmu_isomu18_;
  TBranch *b_onmu_isomu18_;
  mutable bool c_onmu_isomu18_;
  float  onmu_mu50_;
  TBranch *b_onmu_mu50_;
  mutable bool c_onmu_mu50_;
  float  onmu_mu8_;
  TBranch *b_onmu_mu8_;
  mutable bool c_onmu_mu8_;
  float  onmu_vvvl_;
  TBranch *b_onmu_vvvl_;
  mutable bool c_onmu_vvvl_;
  float  onph_ph90_;
  TBranch *b_onph_ph90_;
  mutable bool c_onph_ph90_;
  float  ptll_me_;
  TBranch *b_ptll_me_;
  mutable bool c_ptll_me_;
  float  st_;
  TBranch *b_st_;
  mutable bool c_st_;
  float  top_pt_;
  TBranch *b_top_pt_;
  mutable bool c_top_pt_;
  float  w_bhig_;
  TBranch *b_w_bhig_;
  mutable bool c_w_bhig_;
  float  w_bhig_deep_;
  TBranch *b_w_bhig_deep_;
  mutable bool c_w_bhig_deep_;
  float  w_bhig_deep_proc_;
  TBranch *b_w_bhig_deep_proc_;
  mutable bool c_w_bhig_deep_proc_;
  float  w_bhig_proc_;
  TBranch *b_w_bhig_proc_;
  mutable bool c_w_bhig_proc_;
  float  w_btag_;
  TBranch *b_w_btag_;
  mutable bool c_w_btag_;
  float  w_btag_deep_;
  TBranch *b_w_btag_deep_;
  mutable bool c_w_btag_deep_;
  float  w_btag_deep_proc_;
  TBranch *b_w_btag_deep_proc_;
  mutable bool c_w_btag_deep_proc_;
  float  w_btag_loose_;
  TBranch *b_w_btag_loose_;
  mutable bool c_w_btag_loose_;
  float  w_btag_loose_deep_;
  TBranch *b_w_btag_loose_deep_;
  mutable bool c_w_btag_loose_deep_;
  float  w_btag_loose_deep_proc_;
  TBranch *b_w_btag_loose_deep_proc_;
  mutable bool c_w_btag_loose_deep_proc_;
  float  w_btag_loose_proc_;
  TBranch *b_w_btag_loose_proc_;
  mutable bool c_w_btag_loose_proc_;
  float  w_btag_proc_;
  TBranch *b_w_btag_proc_;
  mutable bool c_w_btag_proc_;
  float  w_btag_tight_;
  TBranch *b_w_btag_tight_;
  mutable bool c_w_btag_tight_;
  float  w_btag_tight_deep_;
  TBranch *b_w_btag_tight_deep_;
  mutable bool c_w_btag_tight_deep_;
  float  w_btag_tight_deep_proc_;
  TBranch *b_w_btag_tight_deep_proc_;
  mutable bool c_w_btag_tight_deep_proc_;
  float  w_btag_tight_proc_;
  TBranch *b_w_btag_tight_proc_;
  mutable bool c_w_btag_tight_proc_;
  float  w_fs_lep_;
  TBranch *b_w_fs_lep_;
  mutable bool c_w_fs_lep_;
  float  w_isr_;
  TBranch *b_w_isr_;
  mutable bool c_w_isr_;
  float  w_lep_;
  TBranch *b_w_lep_;
  mutable bool c_w_lep_;
  float  w_lumi_;
  TBranch *b_w_lumi_;
  mutable bool c_w_lumi_;
  float  w_pu_;
  TBranch *b_w_pu_;
  mutable bool c_w_pu_;
  float  w_toppt_;
  TBranch *b_w_toppt_;
  mutable bool c_w_toppt_;
  float  weight_;
  TBranch *b_weight_;
  mutable bool c_weight_;
  float  weight_rpv_;
  TBranch *b_weight_rpv_;
  mutable bool c_weight_rpv_;
  int  bb_highcsv_idx_;
  TBranch *b_bb_highcsv_idx_;
  mutable bool c_bb_highcsv_idx_;
  int  bb_highcsv_idx_deep_;
  TBranch *b_bb_highcsv_idx_deep_;
  mutable bool c_bb_highcsv_idx_deep_;
  int  hig_bin_;
  TBranch *b_hig_bin_;
  mutable bool c_hig_bin_;
  int  higd_bin_;
  TBranch *b_higd_bin_;
  mutable bool c_higd_bin_;
  int  lumiblock_;
  TBranch *b_lumiblock_;
  mutable bool c_lumiblock_;
  int  mgluino_;
  TBranch *b_mgluino_;
  mutable bool c_mgluino_;
  int  mlsp_;
  TBranch *b_mlsp_;
  mutable bool c_mlsp_;
  int  nbdfl_;
  TBranch *b_nbdfl_;
  mutable bool c_nbdfl_;
  int  nbdfm_;
  TBranch *b_nbdfm_;
  mutable bool c_nbdfm_;
  int  nbdft_;
  TBranch *b_nbdft_;
  mutable bool c_nbdft_;
  int  nbdl_;
  TBranch *b_nbdl_;
  mutable bool c_nbdl_;
  int  nbdm_;
  TBranch *b_nbdm_;
  mutable bool c_nbdm_;
  int  nbdt_;
  TBranch *b_nbdt_;
  mutable bool c_nbdt_;
  int  nbl_;
  TBranch *b_nbl_;
  mutable bool c_nbl_;
  int  nbm_;
  TBranch *b_nbm_;
  mutable bool c_nbm_;
  int  nbm_ra2_;
  TBranch *b_nbm_ra2_;
  mutable bool c_nbm_ra2_;
  int  nbt_;
  TBranch *b_nbt_;
  mutable bool c_nbt_;
  int  nels_;
  TBranch *b_nels_;
  mutable bool c_nels_;
  int  nels_ele23_;
  TBranch *b_nels_ele23_;
  mutable bool c_nels_ele23_;
  int  nels_vvvl_;
  TBranch *b_nels_vvvl_;
  mutable bool c_nels_vvvl_;
  int  nfjets08_;
  TBranch *b_nfjets08_;
  mutable bool c_nfjets08_;
  int  nfjets14_;
  TBranch *b_nfjets14_;
  mutable bool c_nfjets14_;
  int  nisr_me_;
  TBranch *b_nisr_me_;
  mutable bool c_nisr_me_;
  int  njets_;
  TBranch *b_njets_;
  mutable bool c_njets_;
  int  njets_clean_;
  TBranch *b_njets_clean_;
  mutable bool c_njets_clean_;
  int  njets_ra2_;
  TBranch *b_njets_ra2_;
  mutable bool c_njets_ra2_;
  int  nleps_;
  TBranch *b_nleps_;
  mutable bool c_nleps_;
  int  nleps_tm_;
  TBranch *b_nleps_tm_;
  mutable bool c_nleps_tm_;
  int  nmus_;
  TBranch *b_nmus_;
  mutable bool c_nmus_;
  int  nmus_isomu18_;
  TBranch *b_nmus_isomu18_;
  mutable bool c_nmus_isomu18_;
  int  nmus_vvvl_;
  TBranch *b_nmus_vvvl_;
  mutable bool c_nmus_vvvl_;
  int  nph_;
  TBranch *b_nph_;
  mutable bool c_nph_;
  int  npv_;
  TBranch *b_npv_;
  mutable bool c_npv_;
  int  ntks_;
  TBranch *b_ntks_;
  mutable bool c_ntks_;
  int  ntruels_;
  TBranch *b_ntruels_;
  mutable bool c_ntruels_;
  int  ntruleps_;
  TBranch *b_ntruleps_;
  mutable bool c_ntruleps_;
  int  ntrumus_;
  TBranch *b_ntrumus_;
  mutable bool c_ntrumus_;
  int  ntrupv_;
  TBranch *b_ntrupv_;
  mutable bool c_ntrupv_;
  int  ntrutaush_;
  TBranch *b_ntrutaush_;
  mutable bool c_ntrutaush_;
  int  ntrutausl_;
  TBranch *b_ntrutausl_;
  mutable bool c_ntrutausl_;
  int  nvels_;
  TBranch *b_nvels_;
  mutable bool c_nvels_;
  int  nveto_;
  TBranch *b_nveto_;
  mutable bool c_nveto_;
  int  nvleps_;
  TBranch *b_nvleps_;
  mutable bool c_nvleps_;
  int  nvmus_;
  TBranch *b_nvmus_;
  mutable bool c_nvmus_;
  int  run_;
  TBranch *b_run_;
  mutable bool c_run_;
  int  type_;
  TBranch *b_type_;
  mutable bool c_type_;
  std::vector<bool>  els_ele105_;
  std::vector<bool>  *p_els_ele105_;
  TBranch *b_els_ele105_;
  mutable bool c_els_ele105_;
  std::vector<bool>  els_ele23_;
  std::vector<bool>  *p_els_ele23_;
  TBranch *b_els_ele23_;
  mutable bool c_els_ele23_;
  std::vector<bool>  els_ele8_;
  std::vector<bool>  *p_els_ele8_;
  TBranch *b_els_ele8_;
  mutable bool c_els_ele8_;
  std::vector<bool>  els_inz_;
  std::vector<bool>  *p_els_inz_;
  TBranch *b_els_inz_;
  mutable bool c_els_inz_;
  std::vector<bool>  els_inzv_;
  std::vector<bool>  *p_els_inzv_;
  TBranch *b_els_inzv_;
  mutable bool c_els_inzv_;
  std::vector<bool>  els_ispf_;
  std::vector<bool>  *p_els_ispf_;
  TBranch *b_els_ispf_;
  mutable bool c_els_ispf_;
  std::vector<bool>  els_sig_;
  std::vector<bool>  *p_els_sig_;
  TBranch *b_els_sig_;
  mutable bool c_els_sig_;
  std::vector<bool>  els_sigid_;
  std::vector<bool>  *p_els_sigid_;
  TBranch *b_els_sigid_;
  mutable bool c_els_sigid_;
  std::vector<bool>  els_tight_;
  std::vector<bool>  *p_els_tight_;
  TBranch *b_els_tight_;
  mutable bool c_els_tight_;
  std::vector<bool>  els_tm_;
  std::vector<bool>  *p_els_tm_;
  TBranch *b_els_tm_;
  mutable bool c_els_tm_;
  std::vector<bool>  els_vvvl_;
  std::vector<bool>  *p_els_vvvl_;
  TBranch *b_els_vvvl_;
  mutable bool c_els_vvvl_;
  std::vector<bool>  jets_h1_;
  std::vector<bool>  *p_jets_h1_;
  TBranch *b_jets_h1_;
  mutable bool c_jets_h1_;
  std::vector<bool>  jets_h1d_;
  std::vector<bool>  *p_jets_h1d_;
  TBranch *b_jets_h1d_;
  mutable bool c_jets_h1d_;
  std::vector<bool>  jets_h2_;
  std::vector<bool>  *p_jets_h2_;
  TBranch *b_jets_h2_;
  mutable bool c_jets_h2_;
  std::vector<bool>  jets_h2d_;
  std::vector<bool>  *p_jets_h2d_;
  TBranch *b_jets_h2d_;
  mutable bool c_jets_h2d_;
  std::vector<bool>  jets_isisr_;
  std::vector<bool>  *p_jets_isisr_;
  TBranch *b_jets_isisr_;
  mutable bool c_jets_isisr_;
  std::vector<bool>  jets_islep_;
  std::vector<bool>  *p_jets_islep_;
  TBranch *b_jets_islep_;
  mutable bool c_jets_islep_;
  std::vector<bool>  mc_gs_;
  std::vector<bool>  *p_mc_gs_;
  TBranch *b_mc_gs_;
  mutable bool c_mc_gs_;
  std::vector<bool>  mus_bad_;
  std::vector<bool>  *p_mus_bad_;
  TBranch *b_mus_bad_;
  mutable bool c_mus_bad_;
  std::vector<bool>  mus_bad_dupl_;
  std::vector<bool>  *p_mus_bad_dupl_;
  TBranch *b_mus_bad_dupl_;
  mutable bool c_mus_bad_dupl_;
  std::vector<bool>  mus_bad_trkmu_;
  std::vector<bool>  *p_mus_bad_trkmu_;
  TBranch *b_mus_bad_trkmu_;
  mutable bool c_mus_bad_trkmu_;
  std::vector<bool>  mus_demoted_;
  std::vector<bool>  *p_mus_demoted_;
  TBranch *b_mus_demoted_;
  mutable bool c_mus_demoted_;
  std::vector<bool>  mus_inz_;
  std::vector<bool>  *p_mus_inz_;
  TBranch *b_mus_inz_;
  mutable bool c_mus_inz_;
  std::vector<bool>  mus_inzv_;
  std::vector<bool>  *p_mus_inzv_;
  TBranch *b_mus_inzv_;
  mutable bool c_mus_inzv_;
  std::vector<bool>  mus_isomu18_;
  std::vector<bool>  *p_mus_isomu18_;
  TBranch *b_mus_isomu18_;
  mutable bool c_mus_isomu18_;
  std::vector<bool>  mus_mu50_;
  std::vector<bool>  *p_mus_mu50_;
  TBranch *b_mus_mu50_;
  mutable bool c_mus_mu50_;
  std::vector<bool>  mus_mu8_;
  std::vector<bool>  *p_mus_mu8_;
  TBranch *b_mus_mu8_;
  mutable bool c_mus_mu8_;
  std::vector<bool>  mus_sig_;
  std::vector<bool>  *p_mus_sig_;
  TBranch *b_mus_sig_;
  mutable bool c_mus_sig_;
  std::vector<bool>  mus_sigid_;
  std::vector<bool>  *p_mus_sigid_;
  TBranch *b_mus_sigid_;
  mutable bool c_mus_sigid_;
  std::vector<bool>  mus_tight_;
  std::vector<bool>  *p_mus_tight_;
  TBranch *b_mus_tight_;
  mutable bool c_mus_tight_;
  std::vector<bool>  mus_tm_;
  std::vector<bool>  *p_mus_tm_;
  TBranch *b_mus_tm_;
  mutable bool c_mus_tm_;
  std::vector<bool>  mus_trk_quality_;
  std::vector<bool>  *p_mus_trk_quality_;
  TBranch *b_mus_trk_quality_;
  mutable bool c_mus_trk_quality_;
  std::vector<bool>  mus_vvvl_;
  std::vector<bool>  *p_mus_vvvl_;
  TBranch *b_mus_vvvl_;
  mutable bool c_mus_vvvl_;
  std::vector<bool>  ph_ph90_;
  std::vector<bool>  *p_ph_ph90_;
  TBranch *b_ph_ph90_;
  mutable bool c_ph_ph90_;
  std::vector<bool>  ph_tm_;
  std::vector<bool>  *p_ph_tm_;
  TBranch *b_ph_tm_;
  mutable bool c_ph_tm_;
  std::vector<bool>  sys_pass_;
  std::vector<bool>  *p_sys_pass_;
  TBranch *b_sys_pass_;
  mutable bool c_sys_pass_;
  std::vector<bool>  tks_tm_;
  std::vector<bool>  *p_tks_tm_;
  TBranch *b_tks_tm_;
  mutable bool c_tks_tm_;
  std::vector<bool>  trig_;
  std::vector<bool>  *p_trig_;
  TBranch *b_trig_;
  mutable bool c_trig_;
  std::vector<float>  bb_m_;
  std::vector<float>  *p_bb_m_;
  TBranch *b_bb_m_;
  mutable bool c_bb_m_;
  std::vector<float>  bb_m_deep_;
  std::vector<float>  *p_bb_m_deep_;
  TBranch *b_bb_m_deep_;
  mutable bool c_bb_m_deep_;
  std::vector<float>  bb_pt_;
  std::vector<float>  *p_bb_pt_;
  TBranch *b_bb_pt_;
  mutable bool c_bb_pt_;
  std::vector<float>  bb_pt_deep_;
  std::vector<float>  *p_bb_pt_deep_;
  TBranch *b_bb_pt_deep_;
  mutable bool c_bb_pt_deep_;
  std::vector<float>  dr_bb_;
  std::vector<float>  *p_dr_bb_;
  TBranch *b_dr_bb_;
  mutable bool c_dr_bb_;
  std::vector<float>  dr_bb_deep_;
  std::vector<float>  *p_dr_bb_deep_;
  TBranch *b_dr_bb_deep_;
  mutable bool c_dr_bb_deep_;
  std::vector<float>  els_d0_;
  std::vector<float>  *p_els_d0_;
  TBranch *b_els_d0_;
  mutable bool c_els_d0_;
  std::vector<float>  els_deta_sctrk_;
  std::vector<float>  *p_els_deta_sctrk_;
  TBranch *b_els_deta_sctrk_;
  mutable bool c_els_deta_sctrk_;
  std::vector<float>  els_dphi_sctrk_;
  std::vector<float>  *p_els_dphi_sctrk_;
  TBranch *b_els_dphi_sctrk_;
  mutable bool c_els_dphi_sctrk_;
  std::vector<float>  els_dz_;
  std::vector<float>  *p_els_dz_;
  TBranch *b_els_dz_;
  mutable bool c_els_dz_;
  std::vector<float>  els_em_e_;
  std::vector<float>  *p_els_em_e_;
  TBranch *b_els_em_e_;
  mutable bool c_els_em_e_;
  std::vector<float>  els_eoverp_;
  std::vector<float>  *p_els_eoverp_;
  TBranch *b_els_eoverp_;
  mutable bool c_els_eoverp_;
  std::vector<float>  els_eta_;
  std::vector<float>  *p_els_eta_;
  TBranch *b_els_eta_;
  mutable bool c_els_eta_;
  std::vector<float>  els_hovere_;
  std::vector<float>  *p_els_hovere_;
  TBranch *b_els_hovere_;
  mutable bool c_els_hovere_;
  std::vector<float>  els_ip3d_;
  std::vector<float>  *p_els_ip3d_;
  TBranch *b_els_ip3d_;
  mutable bool c_els_ip3d_;
  std::vector<float>  els_miniso_;
  std::vector<float>  *p_els_miniso_;
  TBranch *b_els_miniso_;
  mutable bool c_els_miniso_;
  std::vector<float>  els_phi_;
  std::vector<float>  *p_els_phi_;
  TBranch *b_els_phi_;
  mutable bool c_els_phi_;
  std::vector<float>  els_pt_;
  std::vector<float>  *p_els_pt_;
  TBranch *b_els_pt_;
  mutable bool c_els_pt_;
  std::vector<float>  els_reliso_;
  std::vector<float>  *p_els_reliso_;
  TBranch *b_els_reliso_;
  mutable bool c_els_reliso_;
  std::vector<float>  els_sceta_;
  std::vector<float>  *p_els_sceta_;
  TBranch *b_els_sceta_;
  mutable bool c_els_sceta_;
  std::vector<float>  els_scpt_;
  std::vector<float>  *p_els_scpt_;
  TBranch *b_els_scpt_;
  mutable bool c_els_scpt_;
  std::vector<float>  els_trk_pt_;
  std::vector<float>  *p_els_trk_pt_;
  TBranch *b_els_trk_pt_;
  mutable bool c_els_trk_pt_;
  std::vector<float>  els_trk_pterr_;
  std::vector<float>  *p_els_trk_pterr_;
  TBranch *b_els_trk_pterr_;
  mutable bool c_els_trk_pterr_;
  std::vector<float>  els_vvvl_eta_;
  std::vector<float>  *p_els_vvvl_eta_;
  TBranch *b_els_vvvl_eta_;
  mutable bool c_els_vvvl_eta_;
  std::vector<float>  els_vvvl_phi_;
  std::vector<float>  *p_els_vvvl_phi_;
  TBranch *b_els_vvvl_phi_;
  mutable bool c_els_vvvl_phi_;
  std::vector<float>  els_vvvl_pt_;
  std::vector<float>  *p_els_vvvl_pt_;
  TBranch *b_els_vvvl_pt_;
  mutable bool c_els_vvvl_pt_;
  std::vector<float>  fjets08_eta_;
  std::vector<float>  *p_fjets08_eta_;
  TBranch *b_fjets08_eta_;
  mutable bool c_fjets08_eta_;
  std::vector<float>  fjets08_m_;
  std::vector<float>  *p_fjets08_m_;
  TBranch *b_fjets08_m_;
  mutable bool c_fjets08_m_;
  std::vector<float>  fjets08_phi_;
  std::vector<float>  *p_fjets08_phi_;
  TBranch *b_fjets08_phi_;
  mutable bool c_fjets08_phi_;
  std::vector<float>  fjets08_pt_;
  std::vector<float>  *p_fjets08_pt_;
  TBranch *b_fjets08_pt_;
  mutable bool c_fjets08_pt_;
  std::vector<float>  fjets14_eta_;
  std::vector<float>  *p_fjets14_eta_;
  TBranch *b_fjets14_eta_;
  mutable bool c_fjets14_eta_;
  std::vector<float>  fjets14_m_;
  std::vector<float>  *p_fjets14_m_;
  TBranch *b_fjets14_m_;
  mutable bool c_fjets14_m_;
  std::vector<float>  fjets14_phi_;
  std::vector<float>  *p_fjets14_phi_;
  TBranch *b_fjets14_phi_;
  mutable bool c_fjets14_phi_;
  std::vector<float>  fjets14_pt_;
  std::vector<float>  *p_fjets14_pt_;
  TBranch *b_fjets14_pt_;
  mutable bool c_fjets14_pt_;
  std::vector<float>  jets_csv_;
  std::vector<float>  *p_jets_csv_;
  TBranch *b_jets_csv_;
  mutable bool c_jets_csv_;
  std::vector<float>  jets_csvd_;
  std::vector<float>  *p_jets_csvd_;
  TBranch *b_jets_csvd_;
  mutable bool c_jets_csvd_;
  std::vector<float>  jets_csvdf_;
  std::vector<float>  *p_jets_csvdf_;
  TBranch *b_jets_csvdf_;
  mutable bool c_jets_csvdf_;
  std::vector<float>  jets_eta_;
  std::vector<float>  *p_jets_eta_;
  TBranch *b_jets_eta_;
  mutable bool c_jets_eta_;
  std::vector<float>  jets_gen_pt_;
  std::vector<float>  *p_jets_gen_pt_;
  TBranch *b_jets_gen_pt_;
  mutable bool c_jets_gen_pt_;
  std::vector<float>  jets_m_;
  std::vector<float>  *p_jets_m_;
  TBranch *b_jets_m_;
  mutable bool c_jets_m_;
  std::vector<float>  jets_phi_;
  std::vector<float>  *p_jets_phi_;
  TBranch *b_jets_phi_;
  mutable bool c_jets_phi_;
  std::vector<float>  jets_pt_;
  std::vector<float>  *p_jets_pt_;
  TBranch *b_jets_pt_;
  mutable bool c_jets_pt_;
  std::vector<float>  leps_eta_;
  std::vector<float>  *p_leps_eta_;
  TBranch *b_leps_eta_;
  mutable bool c_leps_eta_;
  std::vector<float>  leps_id_;
  std::vector<float>  *p_leps_id_;
  TBranch *b_leps_id_;
  mutable bool c_leps_id_;
  std::vector<float>  leps_phi_;
  std::vector<float>  *p_leps_phi_;
  TBranch *b_leps_phi_;
  mutable bool c_leps_phi_;
  std::vector<float>  leps_pt_;
  std::vector<float>  *p_leps_pt_;
  TBranch *b_leps_pt_;
  mutable bool c_leps_pt_;
  std::vector<float>  mc_eta_;
  std::vector<float>  *p_mc_eta_;
  TBranch *b_mc_eta_;
  mutable bool c_mc_eta_;
  std::vector<float>  mc_gs_dau_dr_;
  std::vector<float>  *p_mc_gs_dau_dr_;
  TBranch *b_mc_gs_dau_dr_;
  mutable bool c_mc_gs_dau_dr_;
  std::vector<float>  mc_mass_;
  std::vector<float>  *p_mc_mass_;
  TBranch *b_mc_mass_;
  mutable bool c_mc_mass_;
  std::vector<float>  mc_phi_;
  std::vector<float>  *p_mc_phi_;
  TBranch *b_mc_phi_;
  mutable bool c_mc_phi_;
  std::vector<float>  mc_pt_;
  std::vector<float>  *p_mc_pt_;
  TBranch *b_mc_pt_;
  mutable bool c_mc_pt_;
  std::vector<float>  mus_d0_;
  std::vector<float>  *p_mus_d0_;
  TBranch *b_mus_d0_;
  mutable bool c_mus_d0_;
  std::vector<float>  mus_dz_;
  std::vector<float>  *p_mus_dz_;
  TBranch *b_mus_dz_;
  mutable bool c_mus_dz_;
  std::vector<float>  mus_em_e_;
  std::vector<float>  *p_mus_em_e_;
  TBranch *b_mus_em_e_;
  mutable bool c_mus_em_e_;
  std::vector<float>  mus_eta_;
  std::vector<float>  *p_mus_eta_;
  TBranch *b_mus_eta_;
  mutable bool c_mus_eta_;
  std::vector<float>  mus_had_e_;
  std::vector<float>  *p_mus_had_e_;
  TBranch *b_mus_had_e_;
  mutable bool c_mus_had_e_;
  std::vector<float>  mus_miniso_;
  std::vector<float>  *p_mus_miniso_;
  TBranch *b_mus_miniso_;
  mutable bool c_mus_miniso_;
  std::vector<float>  mus_phi_;
  std::vector<float>  *p_mus_phi_;
  TBranch *b_mus_phi_;
  mutable bool c_mus_phi_;
  std::vector<float>  mus_pt_;
  std::vector<float>  *p_mus_pt_;
  TBranch *b_mus_pt_;
  mutable bool c_mus_pt_;
  std::vector<float>  mus_pterr_;
  std::vector<float>  *p_mus_pterr_;
  TBranch *b_mus_pterr_;
  mutable bool c_mus_pterr_;
  std::vector<float>  mus_reliso_;
  std::vector<float>  *p_mus_reliso_;
  TBranch *b_mus_reliso_;
  mutable bool c_mus_reliso_;
  std::vector<float>  mus_vvvl_eta_;
  std::vector<float>  *p_mus_vvvl_eta_;
  TBranch *b_mus_vvvl_eta_;
  mutable bool c_mus_vvvl_eta_;
  std::vector<float>  mus_vvvl_phi_;
  std::vector<float>  *p_mus_vvvl_phi_;
  TBranch *b_mus_vvvl_phi_;
  mutable bool c_mus_vvvl_phi_;
  std::vector<float>  mus_vvvl_pt_;
  std::vector<float>  *p_mus_vvvl_pt_;
  TBranch *b_mus_vvvl_pt_;
  mutable bool c_mus_vvvl_pt_;
  std::vector<float>  ph_eta_;
  std::vector<float>  *p_ph_eta_;
  TBranch *b_ph_eta_;
  mutable bool c_ph_eta_;
  std::vector<float>  ph_phi_;
  std::vector<float>  *p_ph_phi_;
  TBranch *b_ph_phi_;
  mutable bool c_ph_phi_;
  std::vector<float>  ph_pt_;
  std::vector<float>  *p_ph_pt_;
  TBranch *b_ph_pt_;
  mutable bool c_ph_pt_;
  std::vector<float>  sys_bchig_;
  std::vector<float>  *p_sys_bchig_;
  TBranch *b_sys_bchig_;
  mutable bool c_sys_bchig_;
  std::vector<float>  sys_bchig_deep_;
  std::vector<float>  *p_sys_bchig_deep_;
  TBranch *b_sys_bchig_deep_;
  mutable bool c_sys_bchig_deep_;
  std::vector<float>  sys_bchig_deep_proc_;
  std::vector<float>  *p_sys_bchig_deep_proc_;
  TBranch *b_sys_bchig_deep_proc_;
  mutable bool c_sys_bchig_deep_proc_;
  std::vector<float>  sys_bchig_proc_;
  std::vector<float>  *p_sys_bchig_proc_;
  TBranch *b_sys_bchig_proc_;
  mutable bool c_sys_bchig_proc_;
  std::vector<float>  sys_bctag_;
  std::vector<float>  *p_sys_bctag_;
  TBranch *b_sys_bctag_;
  mutable bool c_sys_bctag_;
  std::vector<float>  sys_bctag_deep_;
  std::vector<float>  *p_sys_bctag_deep_;
  TBranch *b_sys_bctag_deep_;
  mutable bool c_sys_bctag_deep_;
  std::vector<float>  sys_bctag_deep_proc_;
  std::vector<float>  *p_sys_bctag_deep_proc_;
  TBranch *b_sys_bctag_deep_proc_;
  mutable bool c_sys_bctag_deep_proc_;
  std::vector<float>  sys_bctag_loose_;
  std::vector<float>  *p_sys_bctag_loose_;
  TBranch *b_sys_bctag_loose_;
  mutable bool c_sys_bctag_loose_;
  std::vector<float>  sys_bctag_loose_deep_;
  std::vector<float>  *p_sys_bctag_loose_deep_;
  TBranch *b_sys_bctag_loose_deep_;
  mutable bool c_sys_bctag_loose_deep_;
  std::vector<float>  sys_bctag_loose_deep_proc_;
  std::vector<float>  *p_sys_bctag_loose_deep_proc_;
  TBranch *b_sys_bctag_loose_deep_proc_;
  mutable bool c_sys_bctag_loose_deep_proc_;
  std::vector<float>  sys_bctag_loose_proc_;
  std::vector<float>  *p_sys_bctag_loose_proc_;
  TBranch *b_sys_bctag_loose_proc_;
  mutable bool c_sys_bctag_loose_proc_;
  std::vector<float>  sys_bctag_proc_;
  std::vector<float>  *p_sys_bctag_proc_;
  TBranch *b_sys_bctag_proc_;
  mutable bool c_sys_bctag_proc_;
  std::vector<float>  sys_bctag_tight_;
  std::vector<float>  *p_sys_bctag_tight_;
  TBranch *b_sys_bctag_tight_;
  mutable bool c_sys_bctag_tight_;
  std::vector<float>  sys_bctag_tight_deep_;
  std::vector<float>  *p_sys_bctag_tight_deep_;
  TBranch *b_sys_bctag_tight_deep_;
  mutable bool c_sys_bctag_tight_deep_;
  std::vector<float>  sys_bctag_tight_deep_proc_;
  std::vector<float>  *p_sys_bctag_tight_deep_proc_;
  TBranch *b_sys_bctag_tight_deep_proc_;
  mutable bool c_sys_bctag_tight_deep_proc_;
  std::vector<float>  sys_bctag_tight_proc_;
  std::vector<float>  *p_sys_bctag_tight_proc_;
  TBranch *b_sys_bctag_tight_proc_;
  mutable bool c_sys_bctag_tight_proc_;
  std::vector<float>  sys_fs_bchig_;
  std::vector<float>  *p_sys_fs_bchig_;
  TBranch *b_sys_fs_bchig_;
  mutable bool c_sys_fs_bchig_;
  std::vector<float>  sys_fs_bchig_deep_;
  std::vector<float>  *p_sys_fs_bchig_deep_;
  TBranch *b_sys_fs_bchig_deep_;
  mutable bool c_sys_fs_bchig_deep_;
  std::vector<float>  sys_fs_bctag_;
  std::vector<float>  *p_sys_fs_bctag_;
  TBranch *b_sys_fs_bctag_;
  mutable bool c_sys_fs_bctag_;
  std::vector<float>  sys_fs_bctag_deep_;
  std::vector<float>  *p_sys_fs_bctag_deep_;
  TBranch *b_sys_fs_bctag_deep_;
  mutable bool c_sys_fs_bctag_deep_;
  std::vector<float>  sys_fs_lep_;
  std::vector<float>  *p_sys_fs_lep_;
  TBranch *b_sys_fs_lep_;
  mutable bool c_sys_fs_lep_;
  std::vector<float>  sys_fs_udsghig_;
  std::vector<float>  *p_sys_fs_udsghig_;
  TBranch *b_sys_fs_udsghig_;
  mutable bool c_sys_fs_udsghig_;
  std::vector<float>  sys_fs_udsghig_deep_;
  std::vector<float>  *p_sys_fs_udsghig_deep_;
  TBranch *b_sys_fs_udsghig_deep_;
  mutable bool c_sys_fs_udsghig_deep_;
  std::vector<float>  sys_fs_udsgtag_;
  std::vector<float>  *p_sys_fs_udsgtag_;
  TBranch *b_sys_fs_udsgtag_;
  mutable bool c_sys_fs_udsgtag_;
  std::vector<float>  sys_fs_udsgtag_deep_;
  std::vector<float>  *p_sys_fs_udsgtag_deep_;
  TBranch *b_sys_fs_udsgtag_deep_;
  mutable bool c_sys_fs_udsgtag_deep_;
  std::vector<float>  sys_higd_am_;
  std::vector<float>  *p_sys_higd_am_;
  TBranch *b_sys_higd_am_;
  mutable bool c_sys_higd_am_;
  std::vector<float>  sys_higd_dm_;
  std::vector<float>  *p_sys_higd_dm_;
  TBranch *b_sys_higd_dm_;
  mutable bool c_sys_higd_dm_;
  std::vector<float>  sys_higd_drmax_;
  std::vector<float>  *p_sys_higd_drmax_;
  TBranch *b_sys_higd_drmax_;
  mutable bool c_sys_higd_drmax_;
  std::vector<float>  sys_ht_;
  std::vector<float>  *p_sys_ht_;
  TBranch *b_sys_ht_;
  mutable bool c_sys_ht_;
  std::vector<float>  sys_isr_;
  std::vector<float>  *p_sys_isr_;
  TBranch *b_sys_isr_;
  mutable bool c_sys_isr_;
  std::vector<float>  sys_lep_;
  std::vector<float>  *p_sys_lep_;
  TBranch *b_sys_lep_;
  mutable bool c_sys_lep_;
  std::vector<float>  sys_met_;
  std::vector<float>  *p_sys_met_;
  TBranch *b_sys_met_;
  mutable bool c_sys_met_;
  std::vector<float>  sys_mj12_;
  std::vector<float>  *p_sys_mj12_;
  TBranch *b_sys_mj12_;
  mutable bool c_sys_mj12_;
  std::vector<float>  sys_mj14_;
  std::vector<float>  *p_sys_mj14_;
  TBranch *b_sys_mj14_;
  mutable bool c_sys_mj14_;
  std::vector<float>  sys_mj14_nolep_;
  std::vector<float>  *p_sys_mj14_nolep_;
  TBranch *b_sys_mj14_nolep_;
  mutable bool c_sys_mj14_nolep_;
  std::vector<float>  sys_mt_;
  std::vector<float>  *p_sys_mt_;
  TBranch *b_sys_mt_;
  mutable bool c_sys_mt_;
  std::vector<float>  sys_muf_;
  std::vector<float>  *p_sys_muf_;
  TBranch *b_sys_muf_;
  mutable bool c_sys_muf_;
  std::vector<float>  sys_mur_;
  std::vector<float>  *p_sys_mur_;
  TBranch *b_sys_mur_;
  mutable bool c_sys_mur_;
  std::vector<float>  sys_murf_;
  std::vector<float>  *p_sys_murf_;
  TBranch *b_sys_murf_;
  mutable bool c_sys_murf_;
  std::vector<float>  sys_pdf_;
  std::vector<float>  *p_sys_pdf_;
  TBranch *b_sys_pdf_;
  mutable bool c_sys_pdf_;
  std::vector<float>  sys_pu_;
  std::vector<float>  *p_sys_pu_;
  TBranch *b_sys_pu_;
  mutable bool c_sys_pu_;
  std::vector<float>  sys_st_;
  std::vector<float>  *p_sys_st_;
  TBranch *b_sys_st_;
  mutable bool c_sys_st_;
  std::vector<float>  sys_trig_;
  std::vector<float>  *p_sys_trig_;
  TBranch *b_sys_trig_;
  mutable bool c_sys_trig_;
  std::vector<float>  sys_udsghig_;
  std::vector<float>  *p_sys_udsghig_;
  TBranch *b_sys_udsghig_;
  mutable bool c_sys_udsghig_;
  std::vector<float>  sys_udsghig_deep_;
  std::vector<float>  *p_sys_udsghig_deep_;
  TBranch *b_sys_udsghig_deep_;
  mutable bool c_sys_udsghig_deep_;
  std::vector<float>  sys_udsghig_deep_proc_;
  std::vector<float>  *p_sys_udsghig_deep_proc_;
  TBranch *b_sys_udsghig_deep_proc_;
  mutable bool c_sys_udsghig_deep_proc_;
  std::vector<float>  sys_udsghig_proc_;
  std::vector<float>  *p_sys_udsghig_proc_;
  TBranch *b_sys_udsghig_proc_;
  mutable bool c_sys_udsghig_proc_;
  std::vector<float>  sys_udsgtag_;
  std::vector<float>  *p_sys_udsgtag_;
  TBranch *b_sys_udsgtag_;
  mutable bool c_sys_udsgtag_;
  std::vector<float>  sys_udsgtag_deep_;
  std::vector<float>  *p_sys_udsgtag_deep_;
  TBranch *b_sys_udsgtag_deep_;
  mutable bool c_sys_udsgtag_deep_;
  std::vector<float>  sys_udsgtag_deep_proc_;
  std::vector<float>  *p_sys_udsgtag_deep_proc_;
  TBranch *b_sys_udsgtag_deep_proc_;
  mutable bool c_sys_udsgtag_deep_proc_;
  std::vector<float>  sys_udsgtag_loose_;
  std::vector<float>  *p_sys_udsgtag_loose_;
  TBranch *b_sys_udsgtag_loose_;
  mutable bool c_sys_udsgtag_loose_;
  std::vector<float>  sys_udsgtag_loose_deep_;
  std::vector<float>  *p_sys_udsgtag_loose_deep_;
  TBranch *b_sys_udsgtag_loose_deep_;
  mutable bool c_sys_udsgtag_loose_deep_;
  std::vector<float>  sys_udsgtag_loose_deep_proc_;
  std::vector<float>  *p_sys_udsgtag_loose_deep_proc_;
  TBranch *b_sys_udsgtag_loose_deep_proc_;
  mutable bool c_sys_udsgtag_loose_deep_proc_;
  std::vector<float>  sys_udsgtag_loose_proc_;
  std::vector<float>  *p_sys_udsgtag_loose_proc_;
  TBranch *b_sys_udsgtag_loose_proc_;
  mutable bool c_sys_udsgtag_loose_proc_;
  std::vector<float>  sys_udsgtag_proc_;
  std::vector<float>  *p_sys_udsgtag_proc_;
  TBranch *b_sys_udsgtag_proc_;
  mutable bool c_sys_udsgtag_proc_;
  std::vector<float>  sys_udsgtag_tight_;
  std::vector<float>  *p_sys_udsgtag_tight_;
  TBranch *b_sys_udsgtag_tight_;
  mutable bool c_sys_udsgtag_tight_;
  std::vector<float>  sys_udsgtag_tight_deep_;
  std::vector<float>  *p_sys_udsgtag_tight_deep_;
  TBranch *b_sys_udsgtag_tight_deep_;
  mutable bool c_sys_udsgtag_tight_deep_;
  std::vector<float>  sys_udsgtag_tight_deep_proc_;
  std::vector<float>  *p_sys_udsgtag_tight_deep_proc_;
  TBranch *b_sys_udsgtag_tight_deep_proc_;
  mutable bool c_sys_udsgtag_tight_deep_proc_;
  std::vector<float>  sys_udsgtag_tight_proc_;
  std::vector<float>  *p_sys_udsgtag_tight_proc_;
  TBranch *b_sys_udsgtag_tight_proc_;
  mutable bool c_sys_udsgtag_tight_proc_;
  std::vector<float>  tks_d0_;
  std::vector<float>  *p_tks_d0_;
  TBranch *b_tks_d0_;
  mutable bool c_tks_d0_;
  std::vector<float>  tks_dz_;
  std::vector<float>  *p_tks_dz_;
  TBranch *b_tks_dz_;
  mutable bool c_tks_dz_;
  std::vector<float>  tks_eta_;
  std::vector<float>  *p_tks_eta_;
  TBranch *b_tks_eta_;
  mutable bool c_tks_eta_;
  std::vector<float>  tks_miniso_;
  std::vector<float>  *p_tks_miniso_;
  TBranch *b_tks_miniso_;
  mutable bool c_tks_miniso_;
  std::vector<float>  tks_mt_;
  std::vector<float>  *p_tks_mt_;
  TBranch *b_tks_mt_;
  mutable bool c_tks_mt_;
  std::vector<float>  tks_mt2_;
  std::vector<float>  *p_tks_mt2_;
  TBranch *b_tks_mt2_;
  mutable bool c_tks_mt2_;
  std::vector<float>  tks_phi_;
  std::vector<float>  *p_tks_phi_;
  TBranch *b_tks_phi_;
  mutable bool c_tks_phi_;
  std::vector<float>  tks_pt_;
  std::vector<float>  *p_tks_pt_;
  TBranch *b_tks_pt_;
  mutable bool c_tks_pt_;
  std::vector<float>  tks_reliso_;
  std::vector<float>  *p_tks_reliso_;
  TBranch *b_tks_reliso_;
  mutable bool c_tks_reliso_;
  std::vector<float>  trig_prescale_;
  std::vector<float>  *p_trig_prescale_;
  TBranch *b_trig_prescale_;
  mutable bool c_trig_prescale_;
  std::vector<float>  w_pdf_;
  std::vector<float>  *p_w_pdf_;
  TBranch *b_w_pdf_;
  mutable bool c_w_pdf_;
  std::vector<int>  bb_gs_flavor_;
  std::vector<int>  *p_bb_gs_flavor_;
  TBranch *b_bb_gs_flavor_;
  mutable bool c_bb_gs_flavor_;
  std::vector<int>  bb_gs_flavor_deep_;
  std::vector<int>  *p_bb_gs_flavor_deep_;
  TBranch *b_bb_gs_flavor_deep_;
  mutable bool c_bb_gs_flavor_deep_;
  std::vector<int>  bb_gs_idx_;
  std::vector<int>  *p_bb_gs_idx_;
  TBranch *b_bb_gs_idx_;
  mutable bool c_bb_gs_idx_;
  std::vector<int>  bb_gs_idx_deep_;
  std::vector<int>  *p_bb_gs_idx_deep_;
  TBranch *b_bb_gs_idx_deep_;
  mutable bool c_bb_gs_idx_deep_;
  std::vector<int>  bb_jet_idx1_;
  std::vector<int>  *p_bb_jet_idx1_;
  TBranch *b_bb_jet_idx1_;
  mutable bool c_bb_jet_idx1_;
  std::vector<int>  bb_jet_idx1_deep_;
  std::vector<int>  *p_bb_jet_idx1_deep_;
  TBranch *b_bb_jet_idx1_deep_;
  mutable bool c_bb_jet_idx1_deep_;
  std::vector<int>  bb_jet_idx2_;
  std::vector<int>  *p_bb_jet_idx2_;
  TBranch *b_bb_jet_idx2_;
  mutable bool c_bb_jet_idx2_;
  std::vector<int>  bb_jet_idx2_deep_;
  std::vector<int>  *p_bb_jet_idx2_deep_;
  TBranch *b_bb_jet_idx2_deep_;
  mutable bool c_bb_jet_idx2_deep_;
  std::vector<int>  els_charge_;
  std::vector<int>  *p_els_charge_;
  TBranch *b_els_charge_;
  mutable bool c_els_charge_;
  std::vector<int>  els_trk_nholes_;
  std::vector<int>  *p_els_trk_nholes_;
  TBranch *b_els_trk_nholes_;
  mutable bool c_els_trk_nholes_;
  std::vector<int>  fjets08_nconst_;
  std::vector<int>  *p_fjets08_nconst_;
  TBranch *b_fjets08_nconst_;
  mutable bool c_fjets08_nconst_;
  std::vector<int>  fjets14_nconst_;
  std::vector<int>  *p_fjets14_nconst_;
  TBranch *b_fjets14_nconst_;
  mutable bool c_fjets14_nconst_;
  std::vector<int>  jets_fjet08_index_;
  std::vector<int>  *p_jets_fjet08_index_;
  TBranch *b_jets_fjet08_index_;
  mutable bool c_jets_fjet08_index_;
  std::vector<int>  jets_fjet12_index_;
  std::vector<int>  *p_jets_fjet12_index_;
  TBranch *b_jets_fjet12_index_;
  mutable bool c_jets_fjet12_index_;
  std::vector<int>  jets_fjet14_index_;
  std::vector<int>  *p_jets_fjet14_index_;
  TBranch *b_jets_fjet14_index_;
  mutable bool c_jets_fjet14_index_;
  std::vector<int>  jets_fjet14_nolep_index_;
  std::vector<int>  *p_jets_fjet14_nolep_index_;
  TBranch *b_jets_fjet14_nolep_index_;
  mutable bool c_jets_fjet14_nolep_index_;
  std::vector<int>  jets_gs_index_;
  std::vector<int>  *p_jets_gs_index_;
  TBranch *b_jets_gs_index_;
  mutable bool c_jets_gs_index_;
  std::vector<int>  jets_hflavor_;
  std::vector<int>  *p_jets_hflavor_;
  TBranch *b_jets_hflavor_;
  mutable bool c_jets_hflavor_;
  std::vector<int>  jets_ntrub_;
  std::vector<int>  *p_jets_ntrub_;
  TBranch *b_jets_ntrub_;
  mutable bool c_jets_ntrub_;
  std::vector<int>  jets_ntruc_;
  std::vector<int>  *p_jets_ntruc_;
  TBranch *b_jets_ntruc_;
  mutable bool c_jets_ntruc_;
  std::vector<int>  jets_pflavor_;
  std::vector<int>  *p_jets_pflavor_;
  TBranch *b_jets_pflavor_;
  mutable bool c_jets_pflavor_;
  std::vector<int>  mc_gs_dau_jetmatch_;
  std::vector<int>  *p_mc_gs_dau_jetmatch_;
  TBranch *b_mc_gs_dau_jetmatch_;
  mutable bool c_mc_gs_dau_jetmatch_;
  std::vector<int>  mc_id_;
  std::vector<int>  *p_mc_id_;
  TBranch *b_mc_id_;
  mutable bool c_mc_id_;
  std::vector<int>  mc_jetidx_;
  std::vector<int>  *p_mc_jetidx_;
  TBranch *b_mc_jetidx_;
  mutable bool c_mc_jetidx_;
  std::vector<int>  mc_mom_;
  std::vector<int>  *p_mc_mom_;
  TBranch *b_mc_mom_;
  mutable bool c_mc_mom_;
  std::vector<int>  mc_momidx_;
  std::vector<int>  *p_mc_momidx_;
  TBranch *b_mc_momidx_;
  mutable bool c_mc_momidx_;
  std::vector<int>  mc_num_dau_;
  std::vector<int>  *p_mc_num_dau_;
  TBranch *b_mc_num_dau_;
  mutable bool c_mc_num_dau_;
  std::vector<int>  mc_status_;
  std::vector<int>  *p_mc_status_;
  TBranch *b_mc_status_;
  mutable bool c_mc_status_;
  std::vector<int>  mus_charge_;
  std::vector<int>  *p_mus_charge_;
  TBranch *b_mus_charge_;
  mutable bool c_mus_charge_;
  std::vector<int>  mus_trk_algo_;
  std::vector<int>  *p_mus_trk_algo_;
  TBranch *b_mus_trk_algo_;
  mutable bool c_mus_trk_algo_;
  std::vector<int>  mus_trk_nholes_in_;
  std::vector<int>  *p_mus_trk_nholes_in_;
  TBranch *b_mus_trk_nholes_in_;
  mutable bool c_mus_trk_nholes_in_;
  std::vector<int>  mus_trk_nholes_out_;
  std::vector<int>  *p_mus_trk_nholes_out_;
  TBranch *b_mus_trk_nholes_out_;
  mutable bool c_mus_trk_nholes_out_;
  std::vector<int>  sys_nbdl_;
  std::vector<int>  *p_sys_nbdl_;
  TBranch *b_sys_nbdl_;
  mutable bool c_sys_nbdl_;
  std::vector<int>  sys_nbdm_;
  std::vector<int>  *p_sys_nbdm_;
  TBranch *b_sys_nbdm_;
  mutable bool c_sys_nbdm_;
  std::vector<int>  sys_nbdt_;
  std::vector<int>  *p_sys_nbdt_;
  TBranch *b_sys_nbdt_;
  mutable bool c_sys_nbdt_;
  std::vector<int>  sys_nbm_;
  std::vector<int>  *p_sys_nbm_;
  TBranch *b_sys_nbm_;
  mutable bool c_sys_nbm_;
  std::vector<int>  sys_njets_;
  std::vector<int>  *p_sys_njets_;
  TBranch *b_sys_njets_;
  mutable bool c_sys_njets_;
  std::vector<int>  tks_pdg_;
  std::vector<int>  *p_tks_pdg_;
  TBranch *b_tks_pdg_;
  mutable bool c_tks_pdg_;
};

baby_base* NewTree(const std::type_info &type);

#include "babymaker/bmaker/interface/baby_full.hh"

#endif