diff --git a/analyses/pluginCMS/CMS_2016_PAS_TOP_15_006.cc b/analyses/pluginCMS/CMS_2016_PAS_TOP_15_006.cc
--- a/analyses/pluginCMS/CMS_2016_PAS_TOP_15_006.cc
+++ b/analyses/pluginCMS/CMS_2016_PAS_TOP_15_006.cc
@@ -1,185 +1,185 @@
 #include "Rivet/Analysis.hh"
 #include "Rivet/Tools/Logging.hh"
 #include "Rivet/Projections/FinalState.hh"
 #include "Rivet/Projections/FastJets.hh"
 #include "Rivet/Projections/DressedLeptons.hh"
 #include "Rivet/Projections/IdentifiedFinalState.hh"
 #include "Rivet/Projections/VetoedFinalState.hh"
 #include "Rivet/Tools/ParticleName.hh"
 #include "Rivet/Tools/ParticleIdUtils.hh"
 
 namespace Rivet {
 
   namespace { //< only visible in this compilation unit
 
 
     /// @brief Special dressed lepton finder
     ///
     /// Find dressed leptons by clustering all leptons and photons
     class SpecialDressedLeptons : public FinalState {
     public:
 
       /// Constructor
       SpecialDressedLeptons(const FinalState& fs, const Cut& cut)
         : FinalState(cut)
       {
         setName("SpecialDressedLeptons");
         IdentifiedFinalState ifs(fs);
         ifs.acceptIdPair(PID::PHOTON);
         ifs.acceptIdPair(PID::ELECTRON);
         ifs.acceptIdPair(PID::MUON);
         addProjection(ifs, "IFS");
         addProjection(FastJets(ifs, FastJets::ANTIKT, 0.1), "LeptonJets");
       }
 
       /// Clone on the heap
       virtual unique_ptr<Projection> clone() const {
         return unique_ptr<Projection>(new SpecialDressedLeptons(*this));
       }
 
       /// Retrieve the dressed leptons
       const vector<DressedLepton>& dressedLeptons() const { return _clusteredLeptons; }
 
       /// Perform the calculation
       void project(const Event& e) {
         _theParticles.clear();
         _clusteredLeptons.clear();
 
         vector<DressedLepton> allClusteredLeptons;
         const Jets jets = applyProjection<FastJets>(e, "LeptonJets").jetsByPt(5*GeV);
         for (const Jet& jet : jets) {
-          const Particle* lepCand;
+          const Particle* lepCand = 0;
           for (const Particle& cand : jet.particles()) {
             const int absPdgId = cand.abspid();
             if (absPdgId == PID::ELECTRON || absPdgId == PID::MUON) {
-              if (cand.pt() > lepCand->pt()) lepCand = &cand;
+              if ( !lepCand || cand.pt() > lepCand->pt() ) lepCand = &cand;
             }
           }
           // Central lepton must be the major component
           if ((lepCand->pt() < jet.pt()/2.) || (lepCand->pdgId() == 0)) continue;
 
           DressedLepton lepton = DressedLepton(*lepCand);
           for (const Particle& cand : jet.particles()) {
             if (&cand == lepCand) continue;
             lepton.addPhoton(cand, true);
           }
           allClusteredLeptons.push_back(lepton);
         }
 
         for (const DressedLepton& lepton : allClusteredLeptons) {
           if (accept(lepton)) {
             _clusteredLeptons.push_back(lepton);
             _theParticles.push_back(lepton.constituentLepton());
             _theParticles += lepton.constituentPhotons();
           }
         }
       }
 
     private:
 
       /// Container which stores the clustered lepton objects
       vector<DressedLepton> _clusteredLeptons;
 
     };
 
   }
 
 
 
   /// Jet multiplicity in lepton+jets ttbar at 8 TeV
   class CMS_2016_PAS_TOP_15_006 : public Analysis {
   public:
 
     /// Constructor
     DEFAULT_RIVET_ANALYSIS_CTOR(CMS_2016_PAS_TOP_15_006);
 
 
     /// @name Analysis methods
     //@{
 
     /// Set up projections and book histograms
     void init() {
 
       // Complete final state
       FinalState fs;
       Cut superLooseLeptonCuts = Cuts::pt > 5*GeV;
       SpecialDressedLeptons dressedleptons(fs, superLooseLeptonCuts);
       addProjection(dressedleptons, "DressedLeptons");
 
       // Projection for jets
       VetoedFinalState fsForJets(fs);
       fsForJets.addVetoOnThisFinalState(dressedleptons);
       addProjection(FastJets(fsForJets, FastJets::ANTIKT, 0.5), "Jets");
 
       // Booking of histograms
       _normedElectronMuonHisto = bookHisto1D("normedElectronMuonHisto", 7, 3.5, 10.5,
                                              "Normalized differential cross section in lepton+jets channel", "Jet multiplicity", "Normed units");
       _absXSElectronMuonHisto = bookHisto1D("absXSElectronMuonHisto", 7, 3.5, 10.5,
                                             "Differential cross section in lepton+jets channel", "Jet multiplicity", "pb");
     }
 
 
     /// Per-event analysis
     void analyze(const Event& event) {
       const double weight = event.weight();
 
       // Select ttbar -> lepton+jets
       const SpecialDressedLeptons& dressedleptons = applyProjection<SpecialDressedLeptons>(event, "DressedLeptons");
       vector<FourMomentum> selleptons;
       for (const DressedLepton& dressedlepton : dressedleptons.dressedLeptons()) {
         // Select good leptons
         if (dressedlepton.pT() > 30*GeV && dressedlepton.abseta() < 2.4) selleptons += dressedlepton.mom();
         // Veto loose leptons
         else if (dressedlepton.pT() > 15*GeV && dressedlepton.abseta() < 2.5) vetoEvent;
       }
       if (selleptons.size() != 1) vetoEvent;
       // Identify hardest tight lepton
       const FourMomentum lepton = selleptons[0];
 
       // Jets
       const FastJets& jets   = applyProjection<FastJets>(event, "Jets");
       const Jets      jets30 = jets.jetsByPt(30*GeV);
       int nJets = 0, nBJets = 0;
       for (const Jet& jet : jets30) {
         if (jet.abseta() > 2.5) continue;
         if (deltaR(jet.momentum(), lepton) < 0.5) continue;
         nJets += 1;
         if (jet.bTagged(Cuts::pT > 5*GeV)) nBJets += 1;
       }
       // Require >= 4 resolved jets, of which two must be b-tagged
       if (nJets < 4 || nBJets < 2) vetoEvent;
 
       // Fill histograms
       _normedElectronMuonHisto->fill(min(nJets, 10), weight);
       _absXSElectronMuonHisto ->fill(min(nJets, 10), weight);
     }
 
 
     void finalize() {
       const double ttbarXS = !std::isnan(crossSectionPerEvent()) ? crossSection() : 252.89*picobarn;
       if (std::isnan(crossSectionPerEvent()))
         MSG_INFO("No valid cross-section given, using NNLO (arXiv:1303.6254; sqrt(s)=8 TeV, m_t=172.5 GeV): " <<
                  ttbarXS/picobarn << " pb");
 
       const double xsPerWeight = ttbarXS/picobarn / sumOfWeights();
       scale(_absXSElectronMuonHisto, xsPerWeight);
 
       normalize(_normedElectronMuonHisto);
     }
 
     //@}
 
 
   private:
 
     /// Histograms
     Histo1DPtr _normedElectronMuonHisto, _absXSElectronMuonHisto;
 
   };
 
 
 
   // The hook for the plugin system
   DECLARE_RIVET_PLUGIN(CMS_2016_PAS_TOP_15_006);
 
 }
diff --git a/include/Rivet/Tools/RivetHepMC.hh b/include/Rivet/Tools/RivetHepMC.hh
--- a/include/Rivet/Tools/RivetHepMC.hh
+++ b/include/Rivet/Tools/RivetHepMC.hh
@@ -1,94 +1,94 @@
 // -*- C++ -*-
 #ifndef RIVET_RivetHepMC_HH
 #define RIVET_RivetHepMC_HH
 
 #ifdef ENABLE_HEPMC_3
 #include "HepMC3/HepMC3.h"
 #include "HepMC3/Relatives.h"
 #include "HepMC3/Reader.h"
 
 namespace Rivet{
   namespace RivetHepMC = HepMC3;
   using RivetHepMC::ConstGenParticlePtr;
   using RivetHepMC::ConstGenVertexPtr;
   using RivetHepMC::Relatives;
   using RivetHepMC::ConstGenHeavyIonPtr;
   
   using HepMC_IO_type = RivetHepMC::Reader;
 
   using PdfInfo = RivetHepMC::GenPdfInfo;
 }
 
 #else
 #include "HepMC/GenEvent.h"
 #include "HepMC/GenParticle.h"
 #include "HepMC/GenVertex.h"
 #include "HepMC/Version.h"
 #include "HepMC/GenRanges.h"
 #include "HepMC/IO_GenEvent.h"
 
 
 namespace Rivet{
   namespace RivetHepMC = HepMC;
   
   // HepMC 2.07 provides its own #defines
   #define ConstGenParticlePtr const HepMC::GenParticle*
   #define ConstGenVertexPtr const HepMC::GenVertex*
   #define ConstGenHeavyIonPtr const HepMC::HeavyIon*
   
   /// @brief Replicated the HepMC3 Relatives syntax using HepMC2 IteratorRanges
   /// This is necessary mainly because of capitalisation differences
   class Relatives{
     
     public:
     
     constexpr Relatives(HepMC::IteratorRange relo): _internal(relo){}
     
     constexpr HepMC::IteratorRange operator()() const {return _internal;}
     operator HepMC::IteratorRange() const {return _internal;}
     
     const static Relatives PARENTS;
     const static Relatives CHILDREN;
     const static Relatives ANCESTORS;
     const static Relatives DESCENDANTS;
     
     private:
     const HepMC::IteratorRange _internal;
     
   };
   
   using HepMC_IO_type = HepMC::IO_GenEvent;
   using PdfInfo = RivetHepMC::PdfInfo;
 
 }
   
 #endif
 
 #include "Rivet/Tools/RivetSTL.hh"
 #include "Rivet/Tools/Exceptions.hh"
 
 
 namespace Rivet {
 
   using RivetHepMC::GenEvent;
   using ConstGenEventPtr = std::shared_ptr<const GenEvent>;
   /// @todo Use mcutils?
 
   namespace HepMCUtils{
   
     std::vector<ConstGenParticlePtr> particles(ConstGenEventPtr ge);
     std::vector<ConstGenParticlePtr> particles(const GenEvent *ge);
     std::vector<ConstGenVertexPtr>   vertices(ConstGenEventPtr ge);
     std::vector<ConstGenVertexPtr>   vertices(const GenEvent *ge);
     std::vector<ConstGenParticlePtr> particles(ConstGenVertexPtr gv, const Relatives &relo);
     std::vector<ConstGenParticlePtr> particles(ConstGenParticlePtr gp, const Relatives &relo);
     int uniqueId(ConstGenParticlePtr gp);
     int particles_size(ConstGenEventPtr ge);
     int particles_size(const GenEvent *ge);
     std::vector<ConstGenParticlePtr> beams(const GenEvent *ge);
     std::shared_ptr<HepMC_IO_type> makeReader(std::istream &istr);
     bool readEvent(std::shared_ptr<HepMC_IO_type> io, std::shared_ptr<GenEvent> evt);
-  };
+  }
 }
 
 #endif
diff --git a/src/Core/zstr/strict_fstream.hpp b/src/Core/zstr/strict_fstream.hpp
--- a/src/Core/zstr/strict_fstream.hpp
+++ b/src/Core/zstr/strict_fstream.hpp
@@ -1,204 +1,204 @@
 #ifndef __STRICT_FSTREAM_HPP
 #define __STRICT_FSTREAM_HPP
 
 #include <cassert>
 #include <fstream>
 #include <cstring>
 #include <string>
 
 #include "Rivet/Config/DummyConfig.hh"
 
 /**
  * This namespace defines wrappers for std::ifstream, std::ofstream, and
  * std::fstream objects. The wrappers perform the following steps:
  * - check the open modes make sense
  * - check that the call to open() is successful
  * - (for input streams) check that the opened file is peek-able
  * - turn on the badbit in the exception mask
  */
 namespace strict_fstream
 {
 
 /// Overload of error-reporting function, to enable use with VS.
 /// Ref: http://stackoverflow.com/a/901316/717706
 static std::string strerror()
 {
     std::string buff(80, '\0');
 #ifdef _WIN32
     if (strerror_s(&buff[0], buff.size(), errno) != 0)
     {
         buff = "Unknown error";
     }
 #elif STRERROR_R_CHAR_P
 // GNU-specific strerror_r()
     auto p = strerror_r(errno, &buff[0], buff.size());
     std::string tmp(p, std::strlen(p));
     std::swap(buff, tmp);
 #else
 // XSI-compliant strerror_r()
     if (strerror_r(errno, &buff[0], buff.size()) != 0)
     {
         buff = "Unknown error";
     }
 #endif
     buff.resize(buff.find('\0'));
     return buff;
 }
 
 /// Exception class thrown by failed operations.
 class Exception
     : public std::exception
 {
 public:
     Exception(const std::string& msg) : _msg(msg) {}
     const char * what() const noexcept { return _msg.c_str(); }
 private:
     std::string _msg;
 }; // class Exception
 
 namespace detail
 {
 
 struct static_method_holder
 {
     static std::string mode_to_string(std::ios_base::openmode mode)
     {
         static const int n_modes = 6;
         static const std::ios_base::openmode mode_val_v[n_modes] =
             {
                 std::ios_base::in,
                 std::ios_base::out,
                 std::ios_base::app,
                 std::ios_base::ate,
                 std::ios_base::trunc,
                 std::ios_base::binary
             };
 
         static const char * mode_name_v[n_modes] =
             {
                 "in",
                 "out",
                 "app",
                 "ate",
                 "trunc",
                 "binary"
             };
         std::string res;
         for (int i = 0; i < n_modes; ++i)
         {
             if (mode & mode_val_v[i])
             {
                 res += (! res.empty()? "|" : "");
                 res += mode_name_v[i];
             }
         }
         if (res.empty()) res = "none";
         return res;
     }
     static void check_mode(const std::string& filename, std::ios_base::openmode mode)
     {
         if ((mode & std::ios_base::trunc) && ! (mode & std::ios_base::out))
         {
             throw Exception(std::string("strict_fstream: open('") + filename + "'): mode error: trunc and not out");
         }
         else if ((mode & std::ios_base::app) && ! (mode & std::ios_base::out))
         {
             throw Exception(std::string("strict_fstream: open('") + filename + "'): mode error: app and not out");
         }
         else if ((mode & std::ios_base::trunc) && (mode & std::ios_base::app))
         {
             throw Exception(std::string("strict_fstream: open('") + filename + "'): mode error: trunc and app");
         }
      }
     static void check_open(std::ios * s_p, const std::string& filename, std::ios_base::openmode mode)
     {
         if (s_p->fail())
         {
             throw Exception(std::string("strict_fstream: open('")
                             + filename + "'," + mode_to_string(mode) + "): open failed: "
                             + strerror());
         }
     }
     static void check_peek(std::istream * is_p, const std::string& filename, std::ios_base::openmode mode)
     {
         bool peek_failed = true;
         try
         {
             is_p->peek();
             peek_failed = is_p->fail();
         }
-        catch (std::ios_base::failure e) {}
+        catch (std::ios_base::failure & e) {}
         if (peek_failed)
         {
             throw Exception(std::string("strict_fstream: open('")
                             + filename + "'," + mode_to_string(mode) + "): peek failed: "
                             + strerror());
         }
         is_p->clear();
     }
 }; // struct static_method_holder
 
 } // namespace detail
 
 class ifstream
     : public std::ifstream
 {
 public:
     ifstream() = default;
     ifstream(const std::string& filename, std::ios_base::openmode mode = std::ios_base::in)
     {
         open(filename, mode);
     }
     void open(const std::string& filename, std::ios_base::openmode mode = std::ios_base::in)
     {
         mode |= std::ios_base::in;
         exceptions(std::ios_base::badbit);
         detail::static_method_holder::check_mode(filename, mode);
         std::ifstream::open(filename, mode);
         detail::static_method_holder::check_open(this, filename, mode);
         detail::static_method_holder::check_peek(this, filename, mode);
     }
 }; // class ifstream
 
 class ofstream
     : public std::ofstream
 {
 public:
     ofstream() = default;
     ofstream(const std::string& filename, std::ios_base::openmode mode = std::ios_base::out)
     {
         open(filename, mode);
     }
     void open(const std::string& filename, std::ios_base::openmode mode = std::ios_base::out)
     {
         mode |= std::ios_base::out;
         exceptions(std::ios_base::badbit);
         detail::static_method_holder::check_mode(filename, mode);
         std::ofstream::open(filename, mode);
         detail::static_method_holder::check_open(this, filename, mode);
     }
 }; // class ofstream
 
 class fstream
     : public std::fstream
 {
 public:
     fstream() = default;
     fstream(const std::string& filename, std::ios_base::openmode mode = std::ios_base::in)
     {
         open(filename, mode);
     }
     void open(const std::string& filename, std::ios_base::openmode mode = std::ios_base::in)
     {
         if (! (mode & std::ios_base::out)) mode |= std::ios_base::in;
         exceptions(std::ios_base::badbit);
         detail::static_method_holder::check_mode(filename, mode);
         std::fstream::open(filename, mode);
         detail::static_method_holder::check_open(this, filename, mode);
         detail::static_method_holder::check_peek(this, filename, mode);
     }
 }; // class fstream
 
 } // namespace strict_fstream
 
 #endif