diff --git a/src/FalcoConfig.cpp b/src/FalcoConfig.cpp
index 8f3164f..5df3556 100644
--- a/src/FalcoConfig.cpp
+++ b/src/FalcoConfig.cpp
@@ -16,26 +16,15 @@
 #include "FalcoConfig.hpp"
 #include "FastqStats.hpp"
 
-#include <fstream>
-#include <sstream>
 #include <sys/stat.h>
 #include <unistd.h>
+
+#include <fstream>
+#include <sstream>
 #include <algorithm>
 #include <sstream>
 
-using std::ostringstream;
-using std::transform;
-using std::string;
-using std::vector;
-using std::unordered_map;
-using std::pair;
-using std::make_pair;
-using std::ifstream;
-using std::runtime_error;
-using std::istringstream;
-using std::cerr;
-
-const string FalcoConfig::FalcoVersion = "1.2.5";
+const std::string FalcoConfig::FalcoVersion = "1.2.5";
 
 /*********************************************************/
 /************** DEFAULT VALUES FOR FILES *****************/
@@ -44,7 +33,7 @@ const string FalcoConfig::FalcoVersion = "1.2.5";
 namespace FileConstants {
   // These will become const bools in the stream reader
   static const std::unordered_map<std::string,
-               std::unordered_map<std::string, double> >
+               std::unordered_map<std::string, double>>
   limits = {
     {"quality_base",{{"ignore",0}}},
     {"duplication",{{"ignore",0}, {"warn",70}, {"error",50}}},
@@ -62,7 +51,7 @@ namespace FileConstants {
   };
 
   /*************** CONTAMINANTS *****************/
-  static const std::vector<std::pair<std::string, std::string> >
+  static const std::vector<std::pair<std::string, std::string>>
   contaminants = {
     {"Illumina Single End Adapter 1","GATCGGAAGAGCTCGTATGCCGTCTTCTGCTTG"},
     {"Illumina Single End Adapter 2","CAAGCAGAAGACGGCATACGAGCTCTTCCGATCT"},
@@ -254,7 +243,7 @@ namespace FileConstants {
 
 // Check if line is not a comment or newline
 inline bool
-is_content_line (const string &line) {
+is_content_line (const std::string &line) {
   // comment
   if (line[0] == '#')
     return false;
@@ -269,7 +258,7 @@ is_content_line (const string &line) {
 // Check existance of config files
 inline bool
 file_exists(const std::string& name) {
-  return (access(name.c_str(), F_OK) == 0);
+  return access(std::data(name), F_OK) == 0;
 }
 
 
@@ -279,7 +268,7 @@ file_exists(const std::string& name) {
 // variable, and files are not read properly
 // if these bytes are not removed
 void
-clean_zero_bytes(string &filename) {
+clean_zero_bytes(std::string &filename) {
   filename.erase(std::remove(begin(filename), end(filename), '\0'), end(filename));
 }
 
@@ -294,10 +283,10 @@ endswith(std::string const &value, std::string const &ending) {
 }
 
 // Removes absolute path from a file
-static string
-strip_path(string full_path) {
+static std::string
+strip_path(std::string full_path) {
   size_t start = full_path.find_last_of('/');
-  if (start == string::npos)
+  if (start == std::string::npos)
     start = 0;
   else
     ++start;
@@ -319,9 +308,9 @@ FalcoConfig::FalcoConfig(const int argc, char *argv[]) {
   read_step = 1;
   format = "";
   threads = 1;
-  contaminants_file = string(PROGRAM_PATH) + "/Configuration/contaminant_list.txt";
-  adapters_file = string(PROGRAM_PATH) + "/Configuration/adapter_list.txt";
-  limits_file = string(PROGRAM_PATH) + "/Configuration/limits.txt";
+  contaminants_file = std::string(PROGRAM_PATH) + "/Configuration/contaminant_list.txt";
+  adapters_file = std::string(PROGRAM_PATH) + "/Configuration/adapter_list.txt";
+  limits_file = std::string(PROGRAM_PATH) + "/Configuration/limits.txt";
 
   clean_zero_bytes(contaminants_file);
   clean_zero_bytes(adapters_file);
@@ -337,16 +326,16 @@ FalcoConfig::FalcoConfig(const int argc, char *argv[]) {
   is_fastq = false;
   is_fastq_gz = false;
 
-  ostringstream ost;
+  std::ostringstream ost;
   for (int i = 0; i < argc; ++i) {
     if (i != 0)
       ost << " " ;
-    ost << string(argv[i]);
+    ost << std::string(argv[i]);
   }
   call = ost.str();
 }
 
-const vector<string> FalcoConfig::values_to_check({
+const std::vector<std::string> FalcoConfig::values_to_check({
     "duplication",
     "kmer",
     "n_content",
@@ -375,13 +364,13 @@ const vector<string> FalcoConfig::values_to_check({
 template <class T>
 bool
 check_if_not_ignored(const T& limits_map,
-                 const string &limit) {
+                 const std::string &limit) {
   if (limits_map.find(limit) == end(limits_map))
-    throw runtime_error("no instructions for limit " + limit);
+    throw std::runtime_error("no instructions for limit " + limit);
 
   const auto the_limit = limits_map.find(limit)->second;
   if (the_limit.find("ignore") == end(the_limit))
-    throw runtime_error("'ignore' option not set for limit " + limit);
+    throw std::runtime_error("'ignore' option not set for limit " + limit);
   
   const bool ret = (the_limit.find("ignore")->second == 0.0);
 
@@ -406,9 +395,9 @@ FalcoConfig::setup() {
 
 void
 FalcoConfig::define_file_format() {
-  transform(begin(format), end(format), begin(format), tolower);
-  string tmp_filename = filename;
-  transform(begin(tmp_filename), end(tmp_filename), begin(tmp_filename), tolower);
+  std::transform(begin(format), end(format), begin(format), tolower);
+  std::string tmp_filename = filename;
+  std::transform(begin(tmp_filename), end(tmp_filename), begin(tmp_filename), tolower);
 
   // reset, important bececause the same FalcoConfig object is used
   // across possibly multiple input files
@@ -444,7 +433,7 @@ FalcoConfig::define_file_format() {
 #endif
     else if (format == "fq.gz" || format == "fastq.gz") is_fastq_gz = true;
     else if (format == "fq" || format == "fastq") is_fastq = true;
-    else throw runtime_error("unrecognized file format: " + format);
+    else throw std::runtime_error("unrecognized file format: " + format);
   }
 }
 
@@ -454,38 +443,38 @@ FalcoConfig::read_limits() {
   limits = FileConstants::limits;
   if (!file_exists(limits_file)) {
     if (!quiet)
-      cerr << "[limits]\tWARNING: using default limits because "
+      std::cerr << "[limits]\tWARNING: using default limits because "
            << "limits file does not exist: " << limits_file << "\n";
   }
   else {
-    ifstream in(limits_file);
+    std::ifstream in(limits_file);
     if (!in)
-      throw runtime_error("problem opening limits file: " + limits_file);
+      throw std::runtime_error("problem opening limits file: " + limits_file);
 
     if (!quiet)
-      cerr << "[limits]\tusing file " << limits_file << "\n"; 
+      std::cerr << "[limits]\tusing file " << limits_file << "\n"; 
 
     // Variables to parse lines
-    string line, instruction;
+    std::string line, instruction;
     double value;
     while (getline(in, line)) {
       // Checks if the line has something to be parsed
       if (is_content_line(line)) {
-        istringstream iss(line);
+        std::istringstream iss(line);
 
         // Every line is a limit, warn/error/ignore and the value
-        string limit;
+        std::string limit;
         if (!(iss >> limit >> instruction >> value))
-          throw runtime_error("malformed limits line: \"" + line + "\"");
+          throw std::runtime_error("malformed limits line: \"" + line + "\"");
 
         if (find(begin(values_to_check), end(values_to_check), limit)
             == end(values_to_check))
-          throw runtime_error("unknown limit option: " + limit);
+          throw std::runtime_error("unknown limit option: " + limit);
 
         if (instruction != "warn" &&
             instruction != "error" &&
             instruction != "ignore")
-          throw runtime_error("unknown instruction for limit " +
+          throw std::runtime_error("unknown instruction for limit " +
                               limit + ": " + instruction);
 
         limits[limit][instruction] = value;
@@ -511,11 +500,11 @@ FalcoConfig::read_limits() {
 }
 
 size_t
-hash_adapter(const string &s) {
+hash_adapter(const std::string &s) {
   size_t ans = 0;
   for (size_t i = 0; i < s.size(); ++i) {
     if (s[i] != 'A' && s[i] != 'C' && s[i] != 'T' && s[i] != 'G')
-      throw runtime_error("Bad adapter (non-ATGC characters): " + s);
+      throw std::runtime_error("Bad adapter (non-ATGC characters): " + s);
 
     ans = (ans << 2) | actg_to_2bit(s[i]);
   }
@@ -527,7 +516,7 @@ void
 FalcoConfig::read_adapters() {
   if (!file_exists(adapters_file)) {
     if (!quiet)
-      cerr << "[adapters]\tWARNING: using default adapters because "
+      std::cerr << "[adapters]\tWARNING: using default adapters because "
            << "adapters file does not exist: " << adapters_file << "\n";
 
     adapter_names = FileConstants::adapter_names;
@@ -541,16 +530,16 @@ FalcoConfig::read_adapters() {
     return;
   }
 
-  ifstream in(adapters_file);
+  std::ifstream in(adapters_file);
   if (!in)
-    throw runtime_error("problem opening adapters file: " + adapters_file);
+    throw std::runtime_error("problem opening adapters file: " + adapters_file);
 
   if (!quiet)
-    cerr << "[adapters]\tusing file " << adapters_file << "\n";
+    std::cerr << "[adapters]\tusing file " << adapters_file << "\n";
 
-  string line, _tmp;
-  vector<string> line_by_space;
-  string adapter_name, adapter_seq;
+  std::string line, _tmp;
+  std::vector<std::string> line_by_space;
+  std::string adapter_name, adapter_seq;
 
   // The adapters file has a space separated name, and the last instance is
   // the biological sequence
@@ -565,14 +554,14 @@ FalcoConfig::read_adapters() {
     if (is_content_line(line)) {
       if (adapter_names.size() > Constants::max_adapters) {
         in.close();
-        throw runtime_error("You are testing too many adapters. The maximum "
+        throw std::runtime_error("You are testing too many adapters. The maximum "
                             "number is 128!");
       }
       adapter_name = "";
       adapter_seq = "";
 
       line_by_space.clear();
-      istringstream iss(line);
+      std::istringstream iss(line);
       while (iss >> _tmp) {
         line_by_space.push_back(_tmp);
       }
@@ -585,7 +574,7 @@ FalcoConfig::read_adapters() {
         adapter_seq = line_by_space.back();
 
         if (adapter_seq.size() > 32) {
-          cerr << "[adapters]\tadapter size is more then 32. Use slow adapters search" << "\n";
+          std::cerr << "[adapters]\tadapter size is more then 32. Use slow adapters search\n";
           do_adapter_optimized = false;
         }
       }
@@ -600,7 +589,7 @@ FalcoConfig::read_adapters() {
         shortest_adapter_size = adapter_size;
       }
       else if (adapter_seq.size() != adapter_size) {
-        cerr << "[adapters]\tadapters have different size. Use slow adapters search" << "\n";
+        std::cerr << "[adapters]\tadapters have different size. Use slow adapters search\n";
         do_adapter_optimized = false;
         if(adapter_seq.size() < shortest_adapter_size){
           shortest_adapter_size = adapter_seq.size();
@@ -615,35 +604,35 @@ void
 FalcoConfig::read_contaminants_file() {
   if (!file_exists(contaminants_file)) {
     if (!quiet)
-      cerr << "[contaminants]\tWARNING: using default contaminants because "
+      std::cerr << "[contaminants]\tWARNING: using default contaminants because "
            << "contaminants file does not exist: " << contaminants_file << "\n";
     contaminants = FileConstants::contaminants;
     return;
   }
-  ifstream in(contaminants_file);
+  std::ifstream in(contaminants_file);
   if (!in)
-    throw runtime_error("problem opening contaminants file: " + contaminants_file);
+    throw std::runtime_error("problem opening contaminants file: " + contaminants_file);
 
   if (!quiet)
-    cerr << "[contaminants]\tusing file " << contaminants_file << "\n";
-  vector<string> line_by_space;
+    std::cerr << "[contaminants]\tusing file " << contaminants_file << "\n";
+  std::vector<std::string> line_by_space;
 
   // The contaminants file has a space separated name, and the last
   // instance is the biological sequence
-  string line;
+  std::string line;
   contaminants.clear();
   while (getline(in, line)) {
     if (is_content_line(line)) {
-      istringstream iss(line);
-      string token;
+      std::istringstream iss(line);
+      std::string token;
       while (iss >> token)
         line_by_space.push_back(token);
 
       if (line_by_space.size() > 1) {
-        string contaminant_name = line_by_space[0];
+        std::string contaminant_name = line_by_space[0];
         for (size_t i = 1; i < line_by_space.size() - 1; ++i)
           contaminant_name += " " + line_by_space[i];
-        contaminants.push_back(make_pair(contaminant_name, line_by_space.back()));
+        contaminants.push_back(std::make_pair(contaminant_name, line_by_space.back()));
       }
       line_by_space.clear();
     }
@@ -651,7 +640,7 @@ FalcoConfig::read_contaminants_file() {
   in.close();
 }
 
-const string FalcoConfig::html_template =
+const std::string FalcoConfig::html_template =
 "<html>"
 "<head>"
 "    <meta charset=\"utf-8\">"
diff --git a/src/FastqStats.cpp b/src/FastqStats.cpp
index 4cf5b14..ec9125f 100644
--- a/src/FastqStats.cpp
+++ b/src/FastqStats.cpp
@@ -16,20 +16,8 @@
 #include "FastqStats.hpp"
 
 #include <algorithm>
-#include <iomanip>
 #include <cmath>
-using std::string;
-using std::vector;
-using std::array;
-using std::unordered_map;
-using std::sort;
-using std::min;
-using std::max;
-using std::ostream;
-using std::pair;
-using std::transform;
-using std::toupper;
-using std::setprecision;
+#include <iomanip>
 
 // ADS: Defining const static integer class variables here for
 // correctness. Optimizer has been ignoring the issue. Hopefully it
@@ -47,9 +35,9 @@ const size_t FastqStats::kBitShiftQuality;
 const size_t FastqStats::kBitShiftAdapter;
 
 // To make the gc models static const
-static array<GCModel, FastqStats::SHORT_READ_THRESHOLD>
-make_gc_models () {
-  array<GCModel, FastqStats::SHORT_READ_THRESHOLD> ans;
+static std::array<GCModel, FastqStats::SHORT_READ_THRESHOLD>
+make_gc_models() {
+  std::array<GCModel, FastqStats::SHORT_READ_THRESHOLD> ans;
   for (size_t i = 0; i < FastqStats::SHORT_READ_THRESHOLD; ++i) {
     ans[i] = GCModel(i);
   }
@@ -85,12 +73,13 @@ FastqStats::FastqStats() {
   position_quality_count.fill(0);
   pos_kmer_count.fill(0);
   pos_adapter_count.fill(0);
-  kmer_count = vector<size_t>(SHORT_READ_THRESHOLD*(Constants::kmer_mask + 1), 0);
+  kmer_count =
+    std::vector<size_t>(SHORT_READ_THRESHOLD * (Constants::kmer_mask + 1), 0);
 }
 
 // Initialize as many gc models as fast bases
-const array<GCModel, FastqStats::SHORT_READ_THRESHOLD>
-FastqStats::gc_models = make_gc_models();
+const std::array<GCModel, FastqStats::SHORT_READ_THRESHOLD>
+  FastqStats::gc_models = make_gc_models();
 
 // When we read new bases, dynamically allocate new space for their statistics
 void
@@ -110,10 +99,10 @@ FastqStats::allocate_new_base(const bool ignore_tile) {
   // space for tile quality in each position.
   //
   if (!ignore_tile) {
-    for (auto  &v : tile_position_quality) {
+    for (auto &v : tile_position_quality) {
       v.second.push_back(0);
     }
-    for (auto  &v : tile_position_count) {
+    for (auto &v : tile_position_count) {
       v.second.push_back(0);
     }
   }
@@ -154,16 +143,14 @@ FastqStats::summarize() {
   }
 }
 
-
 void
 FastqStats::adjust_tile_maps_len() {
-  for (auto it = begin(tile_position_quality); 
-      it != end(tile_position_quality); it++) {
-    it->second.resize(max_read_length); // Always increase space
+  for (auto it = begin(tile_position_quality); it != end(tile_position_quality);
+       it++) {
+    it->second.resize(max_read_length);  // Always increase space
   }
-  for (auto it = begin(tile_position_count); 
-      it != end(tile_position_count); it++) {
-    it->second.resize(max_read_length); // Always increase space
+  for (auto it = begin(tile_position_count); it != end(tile_position_count);
+       it++) {
+    it->second.resize(max_read_length);  // Always increase space
   }
 }
-
diff --git a/src/HtmlMaker.cpp b/src/HtmlMaker.cpp
index 4767de2..3652ac0 100644
--- a/src/HtmlMaker.cpp
+++ b/src/HtmlMaker.cpp
@@ -14,33 +14,21 @@
  */
 
 #include "HtmlMaker.hpp"
+
 #include <algorithm>
-#include <sstream>
 #include <chrono>
 #include <fstream>
-#include <algorithm>
-
-using std::ostringstream;
-using std::string;
-using std::vector;
-using std::sort;
-using std::ifstream;
-using std::runtime_error;
-using std::chrono::system_clock;
-using std::min;
-
+#include <sstream>
 
 void
-HtmlMaker::put_data(const string &placeholder,
-                    const string &data) {
+HtmlMaker::put_data(const std::string &placeholder, const std::string &data) {
   auto pos = html_boilerplate.find(placeholder);
   // Placeholder not found
-  if (pos == string::npos) {
-    throw runtime_error("placeholder not found: " + placeholder);
-  }
+  if (pos == std::string::npos)
+    throw std::runtime_error("placeholder not found: " + placeholder);
 
   // at least one placeholder found
-  while (pos != string::npos) {
+  while (pos != std::string::npos) {
     html_boilerplate.replace(pos, placeholder.size(), data);
     pos = html_boilerplate.find(placeholder, pos + 1);
   }
@@ -48,9 +36,8 @@ HtmlMaker::put_data(const string &placeholder,
 
 // Comments out html pieces if analyses were skipped
 void
-HtmlMaker::put_comment(string &comment_begin,
-            string &comment_end,
-            bool done) {
+HtmlMaker::put_comment(std::string &comment_begin, std::string &comment_end,
+                       bool done) {
   // put html comments if analysis was skipped
   if (!done) {
     put_data(comment_begin, "<!--");
@@ -67,16 +54,13 @@ HtmlMaker::put_comment(string &comment_begin,
 void
 HtmlMaker::put_file_details(const FalcoConfig &falco_config) {
   // Put file name in filename placeholder
-  put_data("{{filename}}",
-                                falco_config.filename_stripped);
+  put_data("{{filename}}", falco_config.filename_stripped);
 
   // Put date on date placeholder
-  auto tmp = system_clock::to_time_t(system_clock::now());
-  string time_fmt = string(ctime(&tmp));
+  auto tmp =
+    std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
+  std::string time_fmt = std::string(ctime(&tmp));
   put_data("{{date}}", time_fmt);
 }
 
-HtmlMaker::HtmlMaker() {
-  html_boilerplate = FalcoConfig::html_template;
-}
-
+HtmlMaker::HtmlMaker() { html_boilerplate = FalcoConfig::html_template; }
diff --git a/src/Module.cpp b/src/Module.cpp
index f352f51..bb3986f 100644
--- a/src/Module.cpp
+++ b/src/Module.cpp
@@ -14,66 +14,44 @@
  */
 
 #include "Module.hpp"
+
 #include <algorithm>
-#include <iomanip>
+#include <cassert>
+#include <cctype>
 #include <cmath>
-#include <sstream>
 #include <cstdlib>
-#include <cassert>
-
-using std::string;
-using std::vector;
-using std::array;
-using std::unordered_map;
-using std::sort;
-using std::min;
-using std::max;
-using std::ostream;
-using std::pair;
-using std::transform;
-using std::setprecision;
-using std::runtime_error;
-using std::make_pair;
-using std::ostringstream;
-using std::istringstream;
-using std::getline;
-
-template<typename T> using num_lim = std::numeric_limits<T>;
+#include <iomanip>
+#include <sstream>
 
-/*****************************************************************************/
 /******************* AUX FUNCTIONS *******************************************/
-/*****************************************************************************/
 // convert string to uppercase, to be used in making the short summaries where
 // PASS, WARN and FAIL are uppercased
-static string
-toupper(const string &s) {
-  string out;
-  transform(s.begin(), s.end(), std::back_inserter(out),(int (*)(int))toupper);
+static inline std::string
+toupper(const std::string &s) {
+  std::string out{s};
+  std::transform(std::cbegin(out), std::cend(out), std::begin(out),
+                 [](const auto c) { return std::toupper(c); });
   return out;
 }
 
-
 /*****************************************************************************/
 /******************* BASEGROUPS COPIED FROM FASTQC ***************************/
 /*****************************************************************************/
 
 /************* NO BASE GROUP ****************/
 void
-make_default_base_groups(vector<BaseGroup> &base_groups,
-                         const size_t &num_bases) {
+make_default_base_groups(std::vector<BaseGroup> &base_groups,
+                         const std::size_t num_bases) {
   base_groups.clear();
-  for (size_t i = 0; i < num_bases; ++i)
-    base_groups.push_back(BaseGroup(i,i));
+  for (std::size_t i = 0; i < num_bases; ++i)
+    base_groups.push_back(BaseGroup(i, i));
 }
 
-
 /************* EXP BASE GROUP **************/
 void
-make_exponential_base_groups(vector<BaseGroup> &base_groups,
-                 const size_t &num_bases) {
-  size_t starting_base = 0,
-         end_base,
-         interval = 1;
+make_exponential_base_groups(std::vector<BaseGroup> &base_groups,
+                             const std::size_t &num_bases) {
+  std::size_t starting_base = 0, end_base, interval = 1;
 
   base_groups.clear();
   for (; starting_base < num_bases;) {
@@ -96,23 +74,22 @@ make_exponential_base_groups(vector<BaseGroup> &base_groups,
   }
 }
 
-
 /************* LINEAR BASE GROUP *************/
 // aux function to get linear interval
-size_t
-get_linear_interval(const size_t num_bases) {
+std::size_t
+get_linear_interval(const std::size_t num_bases) {
   // The the first 9bp as individual residues since odd stuff
   // can happen there, then we find a grouping value which gives
   // us a total set of groups below 75.  We limit the intervals
   // we try to sensible whole numbers.
-  vector<size_t> baseValues = {2,5,10};
-  size_t multiplier = 1;
+  std::vector<std::size_t> baseValues = {2, 5, 10};
+  std::size_t multiplier = 1;
   while (true) {
-    for (size_t b = 0; b<baseValues.size(); b++) {
-      size_t interval = baseValues[b] * multiplier;
-      size_t group_count = 9 + ((num_bases-9)/interval);
+    for (std::size_t b = 0; b < std::size(baseValues); b++) {
+      std::size_t interval = baseValues[b] * multiplier;
+      std::size_t group_count = 9 + ((num_bases - 9) / interval);
 
-      if ((num_bases-9) % interval != 0)
+      if ((num_bases - 9) % interval != 0)
         group_count++;
 
       if (group_count < 75)
@@ -120,15 +97,15 @@ get_linear_interval(const size_t num_bases) {
     }
     multiplier *= 10;
     if (multiplier == 10000000)
-      throw runtime_error("Couldn't find a sensible interval grouping for len ="
-                      + std::to_string(num_bases));
+      throw std::runtime_error(
+        "Couldn't find a sensible interval grouping for len =" +
+        std::to_string(num_bases));
   }
 }
 
-
 void
-make_linear_base_groups(vector<BaseGroup> &base_groups,
-                        const size_t num_bases) {
+make_linear_base_groups(std::vector<BaseGroup> &base_groups,
+                        const std::size_t num_bases) {
 
   // For lengths below 75bp we just return everything.
   if (num_bases <= 75) {
@@ -137,11 +114,11 @@ make_linear_base_groups(vector<BaseGroup> &base_groups,
   }
 
   // We need to work out what interval we're going to use.
-  const size_t interval = get_linear_interval(num_bases);
-  size_t starting_base = 1;
+  const std::size_t interval = get_linear_interval(num_bases);
+  std::size_t starting_base = 1;
 
   while (starting_base <= num_bases) {
-    size_t end_base = starting_base + interval - 1;
+    std::size_t end_base = starting_base + interval - 1;
 
     if (starting_base < 10)
       end_base = starting_base;
@@ -161,22 +138,23 @@ make_linear_base_groups(vector<BaseGroup> &base_groups,
       starting_base = interval;
     else
       starting_base += interval;
-
   }
 }
 
-template<class T>
-T& operator << (T &out, const BaseGroup &group) {
-  if (group.start == group.end) out << group.start + 1;
-  else out << group.start + 1 << "-" << group.end + 1;
+template <class T>
+T &
+operator<<(T &out, const BaseGroup &group) {
+  if (group.start == group.end)
+    out << group.start + 1;
+  else
+    out << group.start + 1 << "-" << group.end + 1;
   return out;
 }
 
 // FastQC extrapolation of counts to the full file size
-double get_corrected_count(size_t count_at_limit,
-                           size_t num_reads,
-                           size_t dup_level,
-                           size_t num_obs) {
+double
+get_corrected_count(std::size_t count_at_limit, std::size_t num_reads,
+                    std::size_t dup_level, std::size_t num_obs) {
   // See if we can bail out early (ADS: can we know if num_reads <=
   // count_at_limit always holds?)
   if (count_at_limit == num_reads)
@@ -201,10 +179,10 @@ double get_corrected_count(size_t count_at_limit,
   // observation.  Once we're below this we stop caring about the corrected
   // value since it's going to be so close to the observed value thatwe can
   // just return that instead.
-  double limit_of_caring = 1.0 - (num_obs/(num_obs + 0.01));
-  for (size_t i = 0; i < count_at_limit; ++i) {
-    p_not_seeing *= static_cast<double>((num_reads-i)-dup_level) /
-                         static_cast<double>(num_reads-i);
+  double limit_of_caring = 1.0 - (num_obs / (num_obs + 0.01));
+  for (std::size_t i = 0; i < count_at_limit; ++i) {
+    p_not_seeing *= static_cast<double>((num_reads - i) - dup_level) /
+                    static_cast<double>(num_reads - i);
 
     if (p_not_seeing < limit_of_caring) {
       p_not_seeing = 0;
@@ -214,26 +192,27 @@ double get_corrected_count(size_t count_at_limit,
 
   // Now we can assume that the number we observed can be
   // scaled up by this proportion
-  return num_obs/std::max(num_lim<double>::min(), 1.0 - p_not_seeing);
+  return num_obs /
+         std::max(std::numeric_limits<double>::min(), 1.0 - p_not_seeing);
 }
 
 // Function to calculate the deviation of a histogram with 100 bins from a
 // theoretical normal distribution with same mode and standard deviation
 double
-sum_deviation_from_normal(const array <double, 101> &gc_count,
-                          array <double, 101> &theoretical) {
+sum_deviation_from_normal(const std::array<double, 101> &gc_count,
+                          std::array<double, 101> &theoretical) {
   /******************* BEGIN COPIED FROM FASTQC **********************/
-  const size_t num_gc_bins = 101;
+  const std::size_t num_gc_bins = 101;
 
   // Sum of all gc counts in all histogram bins
   double total_count = 0.0;
 
   // We use the mode to calculate the theoretical distribution
   // so that we cope better with skewed distributions.
-  size_t first_mode = 0;
+  std::size_t first_mode = 0;
   double mode_count = 0.0;
 
-  for (size_t i = 0; i < num_gc_bins; ++i) {
+  for (std::size_t i = 0; i < num_gc_bins; ++i) {
     total_count += gc_count[i];
     if (gc_count[i] > mode_count) {
       mode_count = gc_count[i];
@@ -248,11 +227,11 @@ sum_deviation_from_normal(const array <double, 101> &gc_count,
   // value
 
   double mode = 0;
-  size_t mode_duplicates = 0;
+  std::size_t mode_duplicates = 0;
   bool fell_off_top = true;
 
-  for (size_t i = first_mode; i < num_gc_bins; ++i) {
-    if (gc_count[i] > gc_count[first_mode] - (gc_count[first_mode]/10.0)) {
+  for (std::size_t i = first_mode; i < num_gc_bins; ++i) {
+    if (gc_count[i] > gc_count[first_mode] - (gc_count[first_mode] / 10.0)) {
       mode += i;
       mode_duplicates++;
     }
@@ -264,8 +243,7 @@ sum_deviation_from_normal(const array <double, 101> &gc_count,
 
   bool fell_off_bottom = true;
   for (int i = first_mode - 1; i >= 0; --i) {
-    if (gc_count[i] > gc_count[first_mode]
-                          - (gc_count[first_mode]/10.0)) {
+    if (gc_count[i] > gc_count[first_mode] - (gc_count[first_mode] / 10.0)) {
       mode += i;
       mode_duplicates++;
     }
@@ -280,19 +258,21 @@ sum_deviation_from_normal(const array <double, 101> &gc_count,
     // is off the 0-100% scale then we keep the mode as the
     // centre of the model
     mode = first_mode;
-  } else {
+  }
+  else {
     // ADS: check if we need to avoid divide-by-zero here
-    mode /= std::max(static_cast<size_t>(1), mode_duplicates);
+    mode /= std::max(1ul, mode_duplicates);
   }
 
   // We can now work out a theoretical distribution
   double stdev = 0.0;
-  for (size_t i = 0; i < num_gc_bins; ++i) {
+  for (std::size_t i = 0; i < num_gc_bins; ++i) {
     stdev += (i - mode) * (i - mode) * gc_count[i];
   }
 
   // ADS: check if we need to avoid divide-by-zero here
-  stdev = stdev / std::max(num_lim<double>::min(), total_count - 1.0);
+  stdev =
+    stdev / std::max(std::numeric_limits<double>::min(), total_count - 1.0);
   stdev = sqrt(stdev);
 
   /******************* END COPIED FROM FASTQC **********************/
@@ -301,43 +281,47 @@ sum_deviation_from_normal(const array <double, 101> &gc_count,
   double ans = 0.0, theoretical_sum = 0.0, z;
   theoretical.fill(0);
   // ADS: lonely magic below; what is the 100?
-  for (size_t i = 0; i <= 100; ++i) {
+  for (std::size_t i = 0; i <= 100; ++i) {
     z = i - mode;
     // ADS: check if we need to avoid divide-by-zero here
-    theoretical[i] = exp(- (z*z)/ (2.0 * stdev *stdev));
+    theoretical[i] = std::exp(-(z * z) / (2.0 * stdev * stdev));
     theoretical_sum += theoretical[i];
   }
 
   // Normalize theoretical so it sums to the total of readsq
-  for (size_t i = 0; i <= 100; ++i) {
+  for (std::size_t i = 0; i <= 100; ++i) {
     // ADS: check if we need to avoid divide-by-zero here
-    theoretical[i] = theoretical[i] * total_count /
-      std::max(num_lim<double>::min(), theoretical_sum);
+    theoretical[i] =
+      theoretical[i] * total_count /
+      std::max(std::numeric_limits<double>::min(), theoretical_sum);
   }
 
-  for (size_t i = 0; i <= 100; ++i) {
-    ans += fabs(gc_count[i] - theoretical[i]);
+  for (std::size_t i = 0; i <= 100; ++i) {
+    ans += std::fabs(gc_count[i] - theoretical[i]);
   }
   // Fractional deviation (ADS: check if we need to avoid
   // divide-by-zero here)
-  return 100.0 * ans / std::max(num_lim<double>::min(), total_count);
+  return 100.0 * ans /
+         std::max(std::numeric_limits<double>::min(), total_count);
 }
 
 /***************************************************************/
 /********************* ABSTRACT MODULE *************************/
 /***************************************************************/
-Module::Module(const string &_module_name) : module_name(_module_name) {
+Module::Module(const std::string &module_name) : module_name{module_name} {
   // make placeholders
   placeholder = module_name;
 
   // removes spaces
-  placeholder.erase(remove_if(placeholder.begin(),
-        placeholder.end(), isspace), placeholder.end());
+  placeholder.erase(
+    std::remove_if(std::begin(placeholder), std::end(placeholder),
+                   [](const auto c) { return std::isspace(c); }),
+    std::cend(placeholder));
 
   // lowercases it
-  transform(placeholder.begin(),
-            placeholder.end(), placeholder.begin(),
-          [](unsigned char c){ return std::tolower(c); });
+  std::transform(std::cbegin(placeholder), std::cend(placeholder),
+                 std::begin(placeholder),
+                 [](const auto c) { return std::tolower(c); });
 
   // makes html placeholders
   placeholder_name = "{{" + placeholder + "name" + "}}";
@@ -349,28 +333,24 @@ Module::Module(const string &_module_name) : module_name(_module_name) {
   summarized = false;
 }
 
-Module::~Module() {
-
-}
+Module::~Module() {}
 
 void
-Module::write(ostream &os) {
+Module::write(std::ostream &os) {
   if (!summarized)
-    throw runtime_error("Attempted to write module before summarizing : "
-                        + module_name);
+    throw std::runtime_error("Attempted to write module before summarizing : " +
+                             module_name);
   os << ">>" << module_name << "\t" << grade << "\n";
   write_module(os);
   os << ">>END_MODULE\n";
 }
 
 void
-Module::write_short_summary(ostream &os, const string &filename) {
+Module::write_short_summary(std::ostream &os, const std::string &filename) {
   if (!summarized)
-    throw runtime_error("Attempted to write module before summarizing : "
-                        + module_name);
-  os << toupper(grade) << "\t"
-     << module_name << "\t"
-     << filename << "\n";
+    throw std::runtime_error("Attempted to write module before summarizing : " +
+                             module_name);
+  os << toupper(grade) << "\t" << module_name << "\t" << filename << "\n";
 }
 
 // Guarantees the summarized flag is only set to true when module
@@ -388,10 +368,9 @@ Module::summarize(FastqStats &stats) {
 /***************************************************************/
 
 /******************* BASIC STATISTICS **************************/
-const string ModuleBasicStatistics::module_name = "Basic Statistics";
-ModuleBasicStatistics::
-ModuleBasicStatistics(const FalcoConfig &config)
-: Module(ModuleBasicStatistics::module_name) {
+const std::string ModuleBasicStatistics::module_name = "Basic Statistics";
+ModuleBasicStatistics::ModuleBasicStatistics(const FalcoConfig &config) :
+  Module(ModuleBasicStatistics::module_name) {
   is_nanopore = config.nanopore;
   filename_stripped = config.filename_stripped;
 }
@@ -410,36 +389,39 @@ ModuleBasicStatistics::summarize_module(FastqStats &stats) {
   file_type = "Conventional base calls";
   if (is_nanopore) {
     file_encoding = "Oxford Nanopore";
-    //stats.encoding_offset = ?
+    // stats.encoding_offset = ?
   }
   else {
     // File encoding
     const char lowest_char = stats.lowest_char;
 
-    //copied from FastQC:
-    static const size_t SANGER_ENCODING_OFFSET = 33;
+    // copied from FastQC:
+    static const std::size_t SANGER_ENCODING_OFFSET = 33;
     static const char ILLUMINA_1_3_ENCODING_OFFSET = 64;
     if (lowest_char < 33) {
-      throw runtime_error("No known encoding with chars < 33. Yours was " +
-                          std::to_string(lowest_char) + ")");
+      throw std::runtime_error("No known encoding with chars < 33. Yours was " +
+                               std::to_string(lowest_char) + ")");
     }
     else if (lowest_char < 64) {
       file_encoding = "Sanger / Illumina 1.9";
       stats.encoding_offset = SANGER_ENCODING_OFFSET - Constants::quality_zero;
     }
-    else if (lowest_char == ILLUMINA_1_3_ENCODING_OFFSET+1) {
+    else if (lowest_char == ILLUMINA_1_3_ENCODING_OFFSET + 1) {
       file_encoding = "Illumina 1.3";
-      stats.encoding_offset = ILLUMINA_1_3_ENCODING_OFFSET - Constants::quality_zero;
+      stats.encoding_offset =
+        ILLUMINA_1_3_ENCODING_OFFSET - Constants::quality_zero;
     }
     else if (lowest_char <= 126) {
       file_encoding = "Illumina 1.5";
-      stats.encoding_offset = ILLUMINA_1_3_ENCODING_OFFSET - Constants::quality_zero;
+      stats.encoding_offset =
+        ILLUMINA_1_3_ENCODING_OFFSET - Constants::quality_zero;
     }
 
     // found a char but it's not the default one
     else if (lowest_char != stats.lowest_char) {
-      throw runtime_error("No known encodings with chars > 126 (Yours was " +
-                          std::to_string(lowest_char) + ")");
+      throw std::runtime_error(
+        "No known encodings with chars > 126 (Yours was " +
+        std::to_string(lowest_char) + ")");
     }
   }
 
@@ -448,16 +430,17 @@ ModuleBasicStatistics::summarize_module(FastqStats &stats) {
 
   // Average read length
   avg_read_length = 0;
-  size_t total_bases = 0;
-  for (size_t i = 0; i < max_read_length; ++i) {
+  std::size_t total_bases = 0;
+  for (std::size_t i = 0; i < max_read_length; ++i) {
     if (i < FastqStats::SHORT_READ_THRESHOLD)
       total_bases += i * stats.read_length_freq[i];
     else
-      total_bases += i * stats.long_read_length_freq[i - FastqStats::SHORT_READ_THRESHOLD];
+      total_bases +=
+        i * stats.long_read_length_freq[i - FastqStats::SHORT_READ_THRESHOLD];
   }
 
   avg_read_length =
-    total_bases / std::max(static_cast<size_t>(1), total_sequences);
+    total_bases / std::max(static_cast<std::size_t>(1), total_sequences);
 
   // counts bases G and C in each base position
   avg_gc = 0;
@@ -465,17 +448,16 @@ ModuleBasicStatistics::summarize_module(FastqStats &stats) {
   // GC %
   // GS: TODO delete gc calculation during stream and do it using the total G
   // counts in all bases
-  avg_gc = 100 * stats.total_gc / std::max(1.0, static_cast<double>(total_bases));
-
+  avg_gc =
+    100 * stats.total_gc / std::max(1.0, static_cast<double>(total_bases));
 }
 
 // It's always a pass
 void
-ModuleBasicStatistics::make_grade() {
-}
+ModuleBasicStatistics::make_grade() {}
 
 void
-ModuleBasicStatistics::write_module(ostream &os) {
+ModuleBasicStatistics::write_module(std::ostream &os) {
   os << "#Measure\tValue\n";
   os << "Filename\t" << filename_stripped << "\n";
   os << "File type\t" << file_type << "\n";
@@ -485,27 +467,25 @@ ModuleBasicStatistics::write_module(ostream &os) {
   os << "Sequence length\t";
   if (min_read_length == max_read_length) {
     os << min_read_length;
-  } else {
+  }
+  else {
     os << min_read_length << "-" << max_read_length;
   }
   os << "\n";
-  os << "%GC\t" << static_cast<size_t>(avg_gc) << "\n";
+  os << "%GC\t" << static_cast<std::size_t>(avg_gc) << "\n";
 }
 
-string
+std::string
 ModuleBasicStatistics::make_html_data() {
-  ostringstream data;
+  std::ostringstream data;
   data << "<table><thead><tr><th>Measure</th><th>Value"
        << "</th></tr></thead><tbody>";
-  data << "<tr><td>Filename</td><td>" << filename_stripped
-       << "</td></tr>";
-  data << "<tr><td>File type</td><td>" << file_type
-       << "</td></tr>";
-  data << "<tr><td>Encoding</td><td>" << file_encoding
-       << "</td></tr>";
+  data << "<tr><td>Filename</td><td>" << filename_stripped << "</td></tr>";
+  data << "<tr><td>File type</td><td>" << file_type << "</td></tr>";
+  data << "<tr><td>Encoding</td><td>" << file_encoding << "</td></tr>";
   data << "<tr><td>Total Sequences</td><td>" << total_sequences << "</td></tr>";
-  data << "<tr><td>Sequences Flagged As Poor Quality</td><td>"
-       << num_poor << "</td></tr>";
+  data << "<tr><td>Sequences Flagged As Poor Quality</td><td>" << num_poor
+       << "</td></tr>";
   data << "<tr><td>Sequence length</td><td>";
   if (min_read_length != max_read_length) {
     data << min_read_length << " - " << max_read_length;
@@ -521,31 +501,31 @@ ModuleBasicStatistics::make_html_data() {
 
 void
 ModuleBasicStatistics::read_data_line(const std::string &line) {
-  string lhs,rhs;
-  istringstream iss(line);
+  std::string lhs, rhs;
+  std::istringstream iss(line);
 
   // get text before and after tab
-  getline(iss, lhs, '\t');
-  getline(iss, rhs, '\t');
+  std::getline(iss, lhs, '\t');
+  std::getline(iss, rhs, '\t');
 
-  if (lhs ==  "Filename")
+  if (lhs == "Filename")
     filename_stripped = rhs;
-  else if (lhs ==  "File type")
+  else if (lhs == "File type")
     file_type = rhs;
-  else if (lhs ==  "Encoding")
+  else if (lhs == "Encoding")
     file_encoding = rhs;
-  else if (lhs ==  "Total Sequences")
+  else if (lhs == "Total Sequences")
     total_sequences = atoi(rhs.c_str());
-  else if (lhs ==  "Sequences flagged as poor quality")
+  else if (lhs == "Sequences flagged as poor quality")
     num_poor = atoi(rhs.c_str());
 
-  else if (lhs ==  "Sequence length") {
+  else if (lhs == "Sequence length") {
     // non-constant sequence length
-    if (rhs.find("-") != string::npos) {
-      istringstream seq_iss (rhs);
-      string min_l, max_l;
-      getline(seq_iss, min_l, '-');
-      getline(seq_iss, max_l, '-');
+    if (rhs.find("-") != std::string::npos) {
+      std::istringstream seq_iss(rhs);
+      std::string min_l, max_l;
+      std::getline(seq_iss, min_l, '-');
+      std::getline(seq_iss, max_l, '-');
       min_read_length = atoi(min_l.c_str());
       max_read_length = atoi(max_l.c_str());
     }
@@ -553,17 +533,17 @@ ModuleBasicStatistics::read_data_line(const std::string &line) {
   else if (lhs == "%GC")
     avg_gc = atoi(rhs.c_str());
   else {
-    throw runtime_error("malformed basic statistic" + lhs);
+    throw std::runtime_error("malformed basic statistic" + lhs);
   }
 }
 
 /******************* PER BASE SEQUENCE QUALITY **********************/
-const string
-ModulePerBaseSequenceQuality::module_name = "Per base sequence quality";
+const std::string ModulePerBaseSequenceQuality::module_name =
+  "Per base sequence quality";
 
-ModulePerBaseSequenceQuality::ModulePerBaseSequenceQuality
-(const FalcoConfig &config):
-Module(ModulePerBaseSequenceQuality::module_name){
+ModulePerBaseSequenceQuality::ModulePerBaseSequenceQuality(
+  const FalcoConfig &config) :
+  Module(ModulePerBaseSequenceQuality::module_name) {
   auto base_lower = config.limits.find("quality_base_lower");
   auto base_median = config.limits.find("quality_base_median");
 
@@ -578,28 +558,20 @@ Module(ModulePerBaseSequenceQuality::module_name){
 void
 ModulePerBaseSequenceQuality::summarize_module(FastqStats &stats) {
   // Quality quantiles for base positions
-  double ldecile_thresh,
-         lquartile_thresh,
-         median_thresh,
-         uquartile_thresh,
-         udecile_thresh;
-
-  size_t cur_ldecile = 0,
-         cur_lquartile = 0,
-         cur_median = 0,
-         cur_uquartile = 0,
-         cur_udecile = 0;
-
-  size_t ldecile_group_sum = 0,
-         lquartile_group_sum = 0,
-         median_group_sum = 0,
-         uquartile_group_sum = 0,
-         udecile_group_sum = 0;
+  double ldecile_thresh, lquartile_thresh, median_thresh, uquartile_thresh,
+    udecile_thresh;
+
+  std::size_t cur_ldecile = 0, cur_lquartile = 0, cur_median = 0,
+              cur_uquartile = 0, cur_udecile = 0;
+
+  std::size_t ldecile_group_sum = 0, lquartile_group_sum = 0,
+              median_group_sum = 0, uquartile_group_sum = 0,
+              udecile_group_sum = 0;
   double mean_group_sum;
 
-  size_t cur;
-  size_t cur_sum;
-  size_t counts;
+  std::size_t cur;
+  std::size_t cur_sum;
+  std::size_t counts;
   double cur_mean;
   num_bases = stats.max_read_length;
 
@@ -608,22 +580,23 @@ ModulePerBaseSequenceQuality::summarize_module(FastqStats &stats) {
     make_linear_base_groups(base_groups, num_bases);
   }
 
-  else make_default_base_groups(base_groups, num_bases);
-  num_groups = base_groups.size();
+  else
+    make_default_base_groups(base_groups, num_bases);
+  num_groups = std::size(base_groups);
 
   // Reserves space I know I will use
-  group_mean = vector<double>(num_groups, 0.0);
-  group_ldecile = vector<double>(num_groups, 0.0);
-  group_lquartile = vector<double>(num_groups, 0.0);
-  group_median = vector<double>(num_groups, 0.0);
-  group_uquartile = vector<double>(num_groups, 0.0);
-  group_udecile = vector<double>(num_groups, 0.0);
+  group_mean = std::vector<double>(num_groups, 0.0);
+  group_ldecile = std::vector<double>(num_groups, 0.0);
+  group_lquartile = std::vector<double>(num_groups, 0.0);
+  group_median = std::vector<double>(num_groups, 0.0);
+  group_uquartile = std::vector<double>(num_groups, 0.0);
+  group_udecile = std::vector<double>(num_groups, 0.0);
 
   // temp
-  vector <size_t> histogram(128, 0);
-  size_t bases_in_group = 0;
+  std::vector<std::size_t> histogram(128, 0);
+  std::size_t bases_in_group = 0;
 
-  for (size_t group = 0; group < num_groups; ++group) {
+  for (std::size_t group = 0; group < num_groups; ++group) {
     mean_group_sum = 0;
     ldecile_group_sum = 0;
     lquartile_group_sum = 0;
@@ -632,23 +605,26 @@ ModulePerBaseSequenceQuality::summarize_module(FastqStats &stats) {
     udecile_group_sum = 0;
 
     // Find quantiles for each base group
-    for (size_t i = base_groups[group].start;
-              i  <= base_groups[group].end; ++i) {
+    for (std::size_t i = base_groups[group].start; i <= base_groups[group].end;
+         ++i) {
 
       // reset group values
       bases_in_group = 0;
-      for (size_t j = 0; j < 128; ++j)
+      for (std::size_t j = 0; j < 128; ++j)
         histogram[j] = 0;
 
-      for (size_t j = 0; j < FastqStats::kNumQualityValues; ++j) {
+      for (std::size_t j = 0; j < FastqStats::kNumQualityValues; ++j) {
         // get value
         if (i < FastqStats::SHORT_READ_THRESHOLD) {
-          cur = stats.position_quality_count[
-            (i << FastqStats::kBitShiftQuality) | j];
+          cur =
+            stats
+              .position_quality_count[(i << FastqStats::kBitShiftQuality) | j];
         }
         else {
-          cur = stats.long_position_quality_count [
-            ((i - FastqStats::SHORT_READ_THRESHOLD) << FastqStats::kBitShiftQuality) | j];
+          cur = stats.long_position_quality_count
+                  [((i - FastqStats::SHORT_READ_THRESHOLD)
+                    << FastqStats::kBitShiftQuality) |
+                   j];
         }
 
         // Add to Phred histogram
@@ -658,9 +634,12 @@ ModulePerBaseSequenceQuality::summarize_module(FastqStats &stats) {
       // Number of bases seen in position i
       if (i < FastqStats::SHORT_READ_THRESHOLD) {
         bases_in_group += stats.cumulative_read_length_freq[i];
-      } else {
+      }
+      else {
         bases_in_group +=
-          stats.long_cumulative_read_length_freq[i - FastqStats::SHORT_READ_THRESHOLD];
+          stats
+            .long_cumulative_read_length_freq[i -
+                                              FastqStats::SHORT_READ_THRESHOLD];
       }
 
       ldecile_thresh = 0.1 * bases_in_group;
@@ -674,7 +653,7 @@ ModulePerBaseSequenceQuality::summarize_module(FastqStats &stats) {
       cur_sum = 0;
       counts = 0;
 
-      for (size_t j = 0; j < FastqStats::kNumQualityValues; ++j) {
+      for (std::size_t j = 0; j < FastqStats::kNumQualityValues; ++j) {
         // Finds in which bin of the histogram reads are
         cur = histogram[j];
         if (counts < ldecile_thresh && counts + cur >= ldecile_thresh)
@@ -691,9 +670,9 @@ ModulePerBaseSequenceQuality::summarize_module(FastqStats &stats) {
         counts += cur;
       }
 
-      cur_mean = static_cast<double>(cur_sum) /
-                 static_cast<double>(bases_in_group);
-      const size_t offset = stats.encoding_offset;
+      cur_mean =
+        static_cast<double>(cur_sum) / static_cast<double>(bases_in_group);
+      const std::size_t offset = stats.encoding_offset;
       mean_group_sum += cur_mean - offset;
       ldecile_group_sum += cur_ldecile - offset;
       lquartile_group_sum += cur_lquartile - offset;
@@ -702,14 +681,20 @@ ModulePerBaseSequenceQuality::summarize_module(FastqStats &stats) {
       udecile_group_sum += cur_udecile - offset;
     }
 
-    const size_t base_positions = base_groups[group].end - base_groups[group].start + 1;
-    assert(base_positions != static_cast<size_t>(0));
+    const std::size_t base_positions =
+      base_groups[group].end - base_groups[group].start + 1;
+    assert(base_positions != static_cast<std::size_t>(0));
     group_mean[group] = mean_group_sum / base_positions;
-    group_ldecile[group] = static_cast<double>(ldecile_group_sum) / base_positions;
-    group_lquartile[group] = static_cast<double>(lquartile_group_sum) / base_positions;
-    group_median[group] = static_cast<double>(median_group_sum) / base_positions;
-    group_uquartile[group] = static_cast<double>(uquartile_group_sum) / base_positions;
-    group_udecile[group] = static_cast<double>(udecile_group_sum) / base_positions;
+    group_ldecile[group] =
+      static_cast<double>(ldecile_group_sum) / base_positions;
+    group_lquartile[group] =
+      static_cast<double>(lquartile_group_sum) / base_positions;
+    group_median[group] =
+      static_cast<double>(median_group_sum) / base_positions;
+    group_uquartile[group] =
+      static_cast<double>(uquartile_group_sum) / base_positions;
+    group_udecile[group] =
+      static_cast<double>(udecile_group_sum) / base_positions;
   }
 }
 
@@ -717,15 +702,16 @@ void
 ModulePerBaseSequenceQuality::make_grade() {
   num_warn = 0;
   num_error = 0;
-  for (size_t i = 0; i < num_groups; ++i) {
+  for (std::size_t i = 0; i < num_groups; ++i) {
     // there was enough data to make this assessment
     if (group_lquartile[i] > 0) {
       if (grade != "fail") {
         if (group_lquartile[i] < base_lower_error ||
             group_median[i] < base_median_error) {
           num_error++;
-        } else if (group_lquartile[i] < base_lower_warn ||
-                   group_median[i] < base_median_warn) {
+        }
+        else if (group_lquartile[i] < base_lower_warn ||
+                 group_median[i] < base_median_warn) {
           num_warn++;
         }
       }
@@ -738,34 +724,28 @@ ModulePerBaseSequenceQuality::make_grade() {
 }
 
 void
-ModulePerBaseSequenceQuality::write_module(ostream &os) {
-  os << "#Base\tMean\tMedian\tLower Quartile\tUpper Quartile" <<
-        "\t10th Percentile\t90th Percentile\n";
+ModulePerBaseSequenceQuality::write_module(std::ostream &os) {
+  os << "#Base\tMean\tMedian\tLower Quartile\tUpper Quartile"
+     << "\t10th Percentile\t90th Percentile\n";
 
   // GS: TODO make base groups
-  for (size_t i = 0; i < num_groups; ++i) {
-    os << base_groups[i] << "\t"
-       << group_mean[i] << "\t"
-       << group_median[i] << "\t"
-       << group_lquartile[i] << "\t"
-       << group_uquartile[i] << "\t"
-       << group_ldecile[i] << "\t"
-       << group_udecile[i] << "\n";
+  for (std::size_t i = 0; i < num_groups; ++i) {
+    os << base_groups[i] << "\t" << group_mean[i] << "\t" << group_median[i]
+       << "\t" << group_lquartile[i] << "\t" << group_uquartile[i] << "\t"
+       << group_ldecile[i] << "\t" << group_udecile[i] << "\n";
   }
 }
 
 // Plotly data
-string
+std::string
 ModulePerBaseSequenceQuality::make_html_data() {
-  ostringstream data;
-  for (size_t i = 0; i < num_groups; ++i) {
+  std::ostringstream data;
+  for (std::size_t i = 0; i < num_groups; ++i) {
     data << "{y : [";
 
-      data << group_ldecile[i] << ", "
-           << group_lquartile[i] << ", "
-           << group_median[i] << ", "
-           << group_uquartile[i] << ", "
-           << group_udecile[i] << "], ";
+    data << group_ldecile[i] << ", " << group_lquartile[i] << ", "
+         << group_median[i] << ", " << group_uquartile[i] << ", "
+         << group_udecile[i] << "], ";
     data << "type : 'box', name : ' ";
     if (base_groups[i].start == base_groups[i].end)
       data << base_groups[i].start + 1;
@@ -792,16 +772,14 @@ ModulePerBaseSequenceQuality::make_html_data() {
 }
 
 void
-ModulePerBaseSequenceQuality::read_data_line(const string &line) {
-
-}
+ModulePerBaseSequenceQuality::read_data_line(const std::string &line) {}
 
 /************** PER TILE SEQUENCE QUALITY ********************/
-const string
-ModulePerTileSequenceQuality::module_name = "Per tile sequence quality";
-ModulePerTileSequenceQuality::
-ModulePerTileSequenceQuality(const FalcoConfig &config) :
-Module(ModulePerTileSequenceQuality::module_name) {
+const std::string ModulePerTileSequenceQuality::module_name =
+  "Per tile sequence quality";
+ModulePerTileSequenceQuality::ModulePerTileSequenceQuality(
+  const FalcoConfig &config) :
+  Module(ModulePerTileSequenceQuality::module_name) {
   auto grade_tile = config.limits.find("tile")->second;
   grade_warn = grade_tile.find("warn")->second;
   grade_error = grade_tile.find("error")->second;
@@ -812,38 +790,38 @@ ModulePerTileSequenceQuality::summarize_module(FastqStats &stats) {
   max_read_length = stats.max_read_length;
   tile_position_quality = stats.tile_position_quality;
   // First I calculate the number of counts for each position
-  vector<size_t> position_counts(max_read_length, 0);
+  std::vector<std::size_t> position_counts(max_read_length, 0);
 
   for (auto v : stats.tile_position_quality) {
-    for (size_t i = 0; i < v.second.size(); ++i) {
-      position_counts[i] +=
-        stats.tile_position_count.find(v.first)->second[i];
+    for (std::size_t i = 0; i < std::size(v.second); ++i) {
+      position_counts[i] += stats.tile_position_count.find(v.first)->second[i];
     }
   }
 
   // Now I calculate the sum of all tile qualities in each position
-  vector<double> mean_in_base(max_read_length, 0.0);
+  std::vector<double> mean_in_base(max_read_length, 0.0);
   for (auto v : tile_position_quality) {
-    for(size_t i = 0; i < v.second.size(); ++i) {
+    for (std::size_t i = 0; i < std::size(v.second); ++i) {
       mean_in_base[i] += v.second[i];
     }
   }
 
   // Now transform sum into mean
-  for (size_t i = 0; i < max_read_length; ++i)
+  for (std::size_t i = 0; i < max_read_length; ++i)
     if (position_counts[i] > 0.0)
       mean_in_base[i] = mean_in_base[i] / position_counts[i];
     else
       mean_in_base[i] = 0.0;
 
   for (auto &v : tile_position_quality) {
-    const size_t lim = v.second.size();
-    for (size_t i = 0; i < lim; ++i) {
+    const std::size_t lim = std::size(v.second);
+    for (std::size_t i = 0; i < lim; ++i) {
       // transform sum of all qualities in mean
       const auto itr = stats.tile_position_count.find(v.first);
       if (itr == cend(stats.tile_position_count))
-        throw runtime_error("failure ModulePerTileSequenceQuality::summarize_module");
-      const size_t count_at_pos = itr->second[i];
+        throw std::runtime_error(
+          "failure ModulePerTileSequenceQuality::summarize_module");
+      const std::size_t count_at_pos = itr->second[i];
 
       if (count_at_pos > 0)
         v.second[i] = v.second[i] / count_at_pos;
@@ -857,14 +835,14 @@ ModulePerTileSequenceQuality::summarize_module(FastqStats &stats) {
   for (auto v : tile_position_quality)
     tiles_sorted.push_back(v.first);
 
-  sort(tiles_sorted.begin(), tiles_sorted.end());
+  std::sort(tiles_sorted.begin(), tiles_sorted.end());
 }
 
 void
 ModulePerTileSequenceQuality::make_grade() {
   grade = "pass";
   for (auto &v : tile_position_quality) {
-    for (size_t i = 0; i < v.second.size(); ++i) {
+    for (std::size_t i = 0; i < std::size(v.second); ++i) {
       if (grade != "fail") {
         if (v.second[i] <= -grade_error) {
           grade = "fail";
@@ -878,14 +856,14 @@ ModulePerTileSequenceQuality::make_grade() {
 }
 
 void
-ModulePerTileSequenceQuality::write_module(ostream &os) {
+ModulePerTileSequenceQuality::write_module(std::ostream &os) {
 
   // prints tiles sorted by value
   os << "#Tile\tBase\tMean\n";
-  for (size_t i = 0; i < tiles_sorted.size(); ++i) {
-    for (size_t j = 0; j < max_read_length; ++j) {
+  for (std::size_t i = 0; i < std::size(tiles_sorted); ++i) {
+    for (std::size_t j = 0; j < max_read_length; ++j) {
 
-      if (tile_position_quality[tiles_sorted[i]].size() >= j) {
+      if (std::size(tile_position_quality[tiles_sorted[i]]) >= j) {
         os << tiles_sorted[i] << "\t" << j + 1 << "\t"
            << tile_position_quality[tiles_sorted[i]][j];
         os << "\n";
@@ -900,16 +878,16 @@ round_quantile(const double val, const double num_quantiles) {
   return static_cast<int>(val * num_quantiles) / num_quantiles;
 }
 
-string
+std::string
 ModulePerTileSequenceQuality::make_html_data() {
   // find quantiles based on data for a standardized color scale
   double min_val = std::numeric_limits<double>::max();
   double max_val = std::numeric_limits<double>::min();
 
-  ostringstream data;
+  std::ostringstream data;
   data << "{x : [";
-  for (size_t i = 0; i < max_read_length; ++i) {
-    data << i+1;
+  for (std::size_t i = 0; i < max_read_length; ++i) {
+    data << i + 1;
     if (i < max_read_length - 1)
       data << ",";
   }
@@ -917,29 +895,34 @@ ModulePerTileSequenceQuality::make_html_data() {
   // Y : Tile
   data << "], y: [";
   bool first_seen = false;
-  for (size_t i = 0; i < tiles_sorted.size(); ++i) {
-    if (!first_seen) first_seen = true;
-    else data << ",";
+  for (std::size_t i = 0; i < std::size(tiles_sorted); ++i) {
+    if (!first_seen)
+      first_seen = true;
+    else
+      data << ",";
     data << tiles_sorted[i];
   }
 
   // Z: quality z score
   data << "], z: [";
   first_seen = false;
-  for (size_t i = 0; i < tiles_sorted.size(); ++i) {
-    if (!first_seen) first_seen = true;
-    else data << ", ";
+  for (std::size_t i = 0; i < std::size(tiles_sorted); ++i) {
+    if (!first_seen)
+      first_seen = true;
+    else
+      data << ", ";
 
     // start new array with all counts
     data << "[";
-    for (size_t j = 0; j < max_read_length; ++j) {
-      const double val =  tile_position_quality[tiles_sorted[i]][j];
+    for (std::size_t j = 0; j < max_read_length; ++j) {
+      const double val = tile_position_quality[tiles_sorted[i]][j];
 
-      data <<  val;
-      if (j < max_read_length - 1) data << ",";
+      data << val;
+      if (j < max_read_length - 1)
+        data << ",";
 
-      max_val = max(max_val, val);
-      min_val = min(min_val, val);
+      max_val = std::max(max_val, val);
+      min_val = std::min(min_val, val);
     }
     data << "]";
   }
@@ -953,7 +936,8 @@ ModulePerTileSequenceQuality::make_html_data() {
   // the color scheme
   static const double num_quantiles = 20.0;
   // ADS: not sure if we need to worry about divide by zero here?
-  double mid_point = round_quantile(min_val/(min_val - max_val), num_quantiles);
+  double mid_point =
+    round_quantile(min_val / (min_val - max_val), num_quantiles);
 
   // - 10: red
   data << "[0.0, 'rgb(210,65,83)'],";
@@ -971,11 +955,11 @@ ModulePerTileSequenceQuality::make_html_data() {
 }
 
 /******************* PER SEQUENCE QUALITY SCORE **********************/
-const string
-ModulePerSequenceQualityScores::module_name = "Per sequence quality scores";
-ModulePerSequenceQualityScores::
-ModulePerSequenceQualityScores(const FalcoConfig &config) :
-Module(ModulePerSequenceQualityScores::module_name) {
+const std::string ModulePerSequenceQualityScores::module_name =
+  "Per sequence quality scores";
+ModulePerSequenceQualityScores::ModulePerSequenceQualityScores(
+  const FalcoConfig &config) :
+  Module(ModulePerSequenceQualityScores::module_name) {
   mode_val = 0;
   mode_ind = 0;
   offset = 0;
@@ -992,7 +976,7 @@ ModulePerSequenceQualityScores::summarize_module(FastqStats &stats) {
   offset = stats.encoding_offset;
 
   // get mode for grade
-  for (size_t i = 0; i < FastqStats::kNumQualityValues; ++i) {
+  for (std::size_t i = 0; i < FastqStats::kNumQualityValues; ++i) {
     if (stats.quality_count[i] > mode_val) {
       mode_val = stats.quality_count[i];
       mode_ind = i - offset;
@@ -1012,21 +996,21 @@ ModulePerSequenceQualityScores::make_grade() {
 }
 
 void
-ModulePerSequenceQualityScores::write_module(ostream &os) {
+ModulePerSequenceQualityScores::write_module(std::ostream &os) {
   os << "#Quality\tCount\n";
-  for (size_t i = 0; i < FastqStats::kNumQualityValues; ++i) {
+  for (std::size_t i = 0; i < FastqStats::kNumQualityValues; ++i) {
     if (quality_count[i] > 0)
       os << i - offset << "\t" << quality_count[i] << "\n";
   }
 }
 
-string
+std::string
 ModulePerSequenceQualityScores::make_html_data() {
-  ostringstream data;
+  std::ostringstream data;
   data << "{x : [";
   bool seen_first = false;
-  for (size_t i = 0; i < FastqStats::kNumQualityValues; ++i) {
-    if (quality_count[i] > 0){
+  for (std::size_t i = 0; i < FastqStats::kNumQualityValues; ++i) {
+    if (quality_count[i] > 0) {
       if (seen_first)
         data << ",";
       else
@@ -1038,8 +1022,8 @@ ModulePerSequenceQualityScores::make_html_data() {
   // Y values: frequency with which they were seen
   data << "], y : [";
   seen_first = false;
-  for (size_t i = 0; i < FastqStats::kNumQualityValues; ++i) {
-    if (quality_count[i] > 0){
+  for (std::size_t i = 0; i < FastqStats::kNumQualityValues; ++i) {
+    if (quality_count[i] > 0) {
       if (seen_first)
         data << ",";
       else
@@ -1054,11 +1038,11 @@ ModulePerSequenceQualityScores::make_html_data() {
 }
 
 /******************* PER BASE SEQUENCE CONTENT **********************/
-const string
-ModulePerBaseSequenceContent::module_name = "Per base sequence content";
-ModulePerBaseSequenceContent::
-ModulePerBaseSequenceContent(const FalcoConfig &config) :
-Module(ModulePerBaseSequenceContent::module_name) {
+const std::string ModulePerBaseSequenceContent::module_name =
+  "Per base sequence content";
+ModulePerBaseSequenceContent::ModulePerBaseSequenceContent(
+  const FalcoConfig &config) :
+  Module(ModulePerBaseSequenceContent::module_name) {
   auto sequence_limits = config.limits.find("sequence")->second;
   sequence_warn = sequence_limits.find("warn")->second;
   sequence_error = sequence_limits.find("error")->second;
@@ -1071,7 +1055,7 @@ void
 ModulePerBaseSequenceContent::summarize_module(FastqStats &stats) {
   double a_group, t_group, g_group, c_group, n_group;
   double a_pos{}, t_pos{}, g_pos{}, c_pos{}, n_pos{};
-  double total; //a+c+t+g+n
+  double total;  // a+c+t+g+n
   max_diff = 0.0;
 
   num_bases = stats.max_read_length;
@@ -1080,81 +1064,93 @@ ModulePerBaseSequenceContent::summarize_module(FastqStats &stats) {
     make_linear_base_groups(base_groups, num_bases);
   }
 
-  else make_default_base_groups(base_groups, num_bases);
-  num_groups = base_groups.size();
+  else
+    make_default_base_groups(base_groups, num_bases);
+  num_groups = std::size(base_groups);
 
-  a_pct = vector<double>(num_groups, 0.0);
-  c_pct = vector<double>(num_groups, 0.0);
-  g_pct = vector<double>(num_groups, 0.0);
-  t_pct = vector<double>(num_groups, 0.0);
+  a_pct = std::vector<double>(num_groups, 0.0);
+  c_pct = std::vector<double>(num_groups, 0.0);
+  g_pct = std::vector<double>(num_groups, 0.0);
+  t_pct = std::vector<double>(num_groups, 0.0);
 
-  for (size_t group = 0; group < num_groups; ++group) {
+  for (std::size_t group = 0; group < num_groups; ++group) {
     // Find quantiles for each base group
     a_group = c_group = g_group = t_group = n_group = 0.0;
-    for (size_t i = base_groups[group].start;
-              i  <= base_groups[group].end; ++i) {
+    for (std::size_t i = base_groups[group].start; i <= base_groups[group].end;
+         ++i) {
       if (i < FastqStats::SHORT_READ_THRESHOLD) {
         a_pos = stats.base_count[(i << FastqStats::kBitShiftNucleotide)];
         c_pos = stats.base_count[(i << FastqStats::kBitShiftNucleotide) | 1];
         t_pos = stats.base_count[(i << FastqStats::kBitShiftNucleotide) | 2];
         g_pos = stats.base_count[(i << FastqStats::kBitShiftNucleotide) | 3];
         n_pos = stats.n_base_count[i];
-      } else {
-        a_pos = stats.long_base_count[
-              ((i - FastqStats::SHORT_READ_THRESHOLD) << FastqStats::kBitShiftNucleotide)
-            ];
-        c_pos = stats.long_base_count[
-              ((i - FastqStats::SHORT_READ_THRESHOLD) << FastqStats::kBitShiftNucleotide) | 1
-            ];
-        t_pos = stats.long_base_count[
-              ((i - FastqStats::SHORT_READ_THRESHOLD) << FastqStats::kBitShiftNucleotide) | 2
-            ];
-        g_pos = stats.long_base_count[
-              ((i - FastqStats::SHORT_READ_THRESHOLD) << FastqStats::kBitShiftNucleotide) | 3
-            ];
-        n_pos = stats.long_n_base_count[
-                i - FastqStats::SHORT_READ_THRESHOLD
-            ];
       }
-      a_group += a_pos; c_group += c_pos; g_group += g_pos; t_group += t_pos;
+      else {
+        a_pos = stats.long_base_count[((i - FastqStats::SHORT_READ_THRESHOLD)
+                                       << FastqStats::kBitShiftNucleotide)];
+        c_pos = stats.long_base_count[((i - FastqStats::SHORT_READ_THRESHOLD)
+                                       << FastqStats::kBitShiftNucleotide) |
+                                      1];
+        t_pos = stats.long_base_count[((i - FastqStats::SHORT_READ_THRESHOLD)
+                                       << FastqStats::kBitShiftNucleotide) |
+                                      2];
+        g_pos = stats.long_base_count[((i - FastqStats::SHORT_READ_THRESHOLD)
+                                       << FastqStats::kBitShiftNucleotide) |
+                                      3];
+        n_pos = stats.long_n_base_count[i - FastqStats::SHORT_READ_THRESHOLD];
+      }
+      a_group += a_pos;
+      c_group += c_pos;
+      g_group += g_pos;
+      t_group += t_pos;
       n_group += n_pos;
 
       const double total_pos =
         static_cast<double>(a_pos + c_pos + g_pos + t_pos + n_pos);
-      a_pos = 100.0 * a_pos / std::max(num_lim<double>::min(), total_pos);
-      c_pos = 100.0 * c_pos / std::max(num_lim<double>::min(), total_pos);
-      g_pos = 100.0 * g_pos / std::max(num_lim<double>::min(), total_pos);
-      t_pos = 100.0 * t_pos / std::max(num_lim<double>::min(), total_pos);
+      a_pos =
+        100.0 * a_pos / std::max(std::numeric_limits<double>::min(), total_pos);
+      c_pos =
+        100.0 * c_pos / std::max(std::numeric_limits<double>::min(), total_pos);
+      g_pos =
+        100.0 * g_pos / std::max(std::numeric_limits<double>::min(), total_pos);
+      t_pos =
+        100.0 * t_pos / std::max(std::numeric_limits<double>::min(), total_pos);
 
       // for WGBS, we only test non-bisulfite treated bases
       if (!is_reverse_complement)
-        max_diff = max(max_diff, fabs(a_pos - g_pos));
+        max_diff = std::max(max_diff, std::fabs(a_pos - g_pos));
       else
-        max_diff = max(max_diff, fabs(c_pos - t_pos));
+        max_diff = std::max(max_diff, std::fabs(c_pos - t_pos));
 
       if (!is_bisulfite) {
-        max_diff = max(max_diff, fabs(a_pos - c_pos));
-        max_diff = max(max_diff, fabs(a_pos - t_pos));
-        max_diff = max(max_diff, fabs(c_pos - g_pos));
-        max_diff = max(max_diff, fabs(t_pos - g_pos));
+        max_diff = std::max(max_diff, std::fabs(a_pos - c_pos));
+        max_diff = std::max(max_diff, std::fabs(a_pos - t_pos));
+        max_diff = std::max(max_diff, std::fabs(c_pos - g_pos));
+        max_diff = std::max(max_diff, std::fabs(t_pos - g_pos));
 
         if (!is_reverse_complement)
-          max_diff = max(max_diff, fabs(c_pos - t_pos));
+          max_diff = std::max(max_diff, std::fabs(c_pos - t_pos));
         else
-          max_diff = max(max_diff, fabs(a_pos - g_pos));
+          max_diff = std::max(max_diff, std::fabs(a_pos - g_pos));
       }
       // WGBS specific base content count
       else {
-        max_diff = max(max_diff, fabs((c_pos + t_pos) - (a_pos + g_pos)));
+        max_diff =
+          std::max(max_diff, std::fabs((c_pos + t_pos) - (a_pos + g_pos)));
       }
     }
 
     // turns above values to percent
-    total = static_cast<double>(a_group + c_group + t_group + g_group + n_group);
-    a_pct[group] = 100.0*a_group / std::max(num_lim<double>::min(), total);
-    c_pct[group] = 100.0*c_group / std::max(num_lim<double>::min(), total);
-    g_pct[group] = 100.0*g_group / std::max(num_lim<double>::min(), total);
-    t_pct[group] = 100.0*t_group / std::max(num_lim<double>::min(), total);
+    total =
+      static_cast<double>(a_group + c_group + t_group + g_group + n_group);
+    a_pct[group] =
+      100.0 * a_group / std::max(std::numeric_limits<double>::min(), total);
+    c_pct[group] =
+      100.0 * c_group / std::max(std::numeric_limits<double>::min(), total);
+    g_pct[group] =
+      100.0 * g_group / std::max(std::numeric_limits<double>::min(), total);
+    t_pct[group] =
+      100.0 * t_group / std::max(std::numeric_limits<double>::min(), total);
   }
 }
 
@@ -1169,54 +1165,54 @@ ModulePerBaseSequenceContent::make_grade() {
 }
 
 void
-ModulePerBaseSequenceContent::write_module(ostream &os) {
+ModulePerBaseSequenceContent::write_module(std::ostream &os) {
   os << "#Base\tG\tA\tT\tC";
   if (is_bisulfite)
     os << "\tC+T\tA+G";
 
   os << "\n";
-  for (size_t i = 0; i < num_groups; ++i) {
-    os << base_groups[i] << "\t" <<
-          g_pct[i] << "\t" <<
-          a_pct[i] << "\t" <<
-          t_pct[i] << "\t" <<
-          c_pct[i];
+  for (std::size_t i = 0; i < num_groups; ++i) {
+    os << base_groups[i] << "\t" << g_pct[i] << "\t" << a_pct[i] << "\t"
+       << t_pct[i] << "\t" << c_pct[i];
 
     if (is_bisulfite) {
-      os << "\t" << c_pct[i]+t_pct[i] << "\t"
-         << a_pct[i]+g_pct[i];
+      os << "\t" << c_pct[i] + t_pct[i] << "\t" << a_pct[i] + g_pct[i];
     }
     os << "\n";
   }
 }
 
-string
+std::string
 ModulePerBaseSequenceContent::make_html_data() {
-  ostringstream data;
+  std::ostringstream data;
   // ATGC
-  for (size_t base = 0; base < 4; ++base) {
+  for (std::size_t base = 0; base < 4; ++base) {
     // start line
     data << "{";
 
     // X values : base position
     data << "x : [";
-    for (size_t i = 0; i < num_groups; ++i) {
+    for (std::size_t i = 0; i < num_groups; ++i) {
       if (base_groups[i].start == base_groups[i].end)
         data << base_groups[i].start + 1;
       else
         data << "\"" << base_groups[i].start + 1 << "-"
-                     << base_groups[i].end + 1 << "\"";
+             << base_groups[i].end + 1 << "\"";
       if (i < num_groups - 1)
         data << ", ";
     }
 
     // Y values: frequency with which they were seen
     data << "], y : [";
-    for (size_t i = 0; i < num_groups; ++i) {
-      if (base == 0) data << a_pct[i];
-      if (base == 1) data << c_pct[i];
-      if (base == 2) data << t_pct[i];
-      if (base == 3) data << g_pct[i];
+    for (std::size_t i = 0; i < num_groups; ++i) {
+      if (base == 0)
+        data << a_pct[i];
+      if (base == 1)
+        data << c_pct[i];
+      if (base == 2)
+        data << t_pct[i];
+      if (base == 3)
+        data << g_pct[i];
       if (i < num_groups - 1)
         data << ", ";
     }
@@ -1243,22 +1239,22 @@ ModulePerBaseSequenceContent::make_html_data() {
 
   // bisulfite dashed lines
   if (is_bisulfite) {
-    for (size_t line = 0; line <= 1; ++line) {
+    for (std::size_t line = 0; line <= 1; ++line) {
       data << "{";
       data << "x : [";
-      for (size_t i = 0; i < num_groups; ++i) {
+      for (std::size_t i = 0; i < num_groups; ++i) {
         if (base_groups[i].start == base_groups[i].end)
           data << base_groups[i].start + 1;
         else
           data << "\"" << base_groups[i].start + 1 << "-"
-                       << base_groups[i].end + 1 << "\"";
+               << base_groups[i].end + 1 << "\"";
         if (i < num_groups - 1)
           data << ", ";
       }
 
       // Y values: frequency with which they were seen
       data << "], y : [";
-      for (size_t i = 0; i < num_groups; ++i) {
+      for (std::size_t i = 0; i < num_groups; ++i) {
         if (line == 0)
           data << a_pct[i] + g_pct[i];
         else
@@ -1270,10 +1266,11 @@ ModulePerBaseSequenceContent::make_html_data() {
       data << "], mode : 'lines', name : '";
       if (line == 0) {
         data << "A+G";
-      } else {
+      }
+      else {
         data << "C+T";
       }
-      data <<  "', ";
+      data << "', ";
 
       // color and dash
       data << "line :{ color : '";
@@ -1288,7 +1285,6 @@ ModulePerBaseSequenceContent::make_html_data() {
       data << "}";
       if (line == 0)
         data << ", ";
-
     }
   }
 
@@ -1296,11 +1292,10 @@ ModulePerBaseSequenceContent::make_html_data() {
 }
 
 /******************* PER SEQUENCE GC CONTENT *****************/
-const string
-ModulePerSequenceGCContent::module_name = "Per sequence GC content";
-ModulePerSequenceGCContent::
-ModulePerSequenceGCContent(const FalcoConfig &config) :
-Module(ModulePerSequenceGCContent::module_name) {
+const std::string ModulePerSequenceGCContent::module_name =
+  "Per sequence GC content";
+ModulePerSequenceGCContent::ModulePerSequenceGCContent(
+  const FalcoConfig &config) : Module(ModulePerSequenceGCContent::module_name) {
   auto gc_vars = config.limits.find("gc_sequence")->second;
   gc_warn = gc_vars.find("warn")->second;
   gc_error = gc_vars.find("error")->second;
@@ -1309,8 +1304,7 @@ Module(ModulePerSequenceGCContent::module_name) {
 void
 ModulePerSequenceGCContent::summarize_module(FastqStats &stats) {
   gc_count = stats.gc_count;
-  gc_deviation = sum_deviation_from_normal(gc_count,
-                                           theoretical_gc_count);
+  gc_deviation = sum_deviation_from_normal(gc_count, theoretical_gc_count);
 }
 
 void
@@ -1324,18 +1318,18 @@ ModulePerSequenceGCContent::make_grade() {
 }
 
 void
-ModulePerSequenceGCContent::write_module(ostream &os) {
+ModulePerSequenceGCContent::write_module(std::ostream &os) {
   os << "#GC Content\tCount\n";
-  for (size_t i = 0; i <= 100; ++i)
+  for (std::size_t i = 0; i <= 100; ++i)
     os << i << "\t" << gc_count[i] << "\n";
 }
 
-string
+std::string
 ModulePerSequenceGCContent::make_html_data() {
-  ostringstream data;
+  std::ostringstream data;
   // Actual count
   data << "{x : [";
-  for (size_t i = 0; i < 101; ++i) {
+  for (std::size_t i = 0; i < 101; ++i) {
     data << i + 1;
     if (i < 101)
       data << ", ";
@@ -1343,7 +1337,7 @@ ModulePerSequenceGCContent::make_html_data() {
 
   // Y values: frequency with which they were seen
   data << "], y : [";
-  for (size_t i = 0; i < 101; ++i) {
+  for (std::size_t i = 0; i < 101; ++i) {
     data << gc_count[i];
     if (i < 101)
       data << ", ";
@@ -1352,7 +1346,7 @@ ModulePerSequenceGCContent::make_html_data() {
 
   // Theoretical count
   data << ", {x : [";
-  for (size_t i = 0; i < 101; ++i) {
+  for (std::size_t i = 0; i < 101; ++i) {
     data << i + 1;
     if (i < 101)
       data << ", ";
@@ -1360,7 +1354,7 @@ ModulePerSequenceGCContent::make_html_data() {
 
   // Y values: frequency with which they were seen
   data << "], y : [";
-  for (size_t i = 0; i < 101; ++i) {
+  for (std::size_t i = 0; i < 101; ++i) {
     data << theoretical_gc_count[i];
     if (i < 101)
       data << ", ";
@@ -1372,11 +1366,9 @@ ModulePerSequenceGCContent::make_html_data() {
 }
 
 /******************* PER BASE N CONTENT **********************/
-const string
-ModulePerBaseNContent::module_name = "Per base N content";
-ModulePerBaseNContent::
-ModulePerBaseNContent(const FalcoConfig &config) :
-Module(ModulePerBaseNContent::module_name) {
+const std::string ModulePerBaseNContent::module_name = "Per base N content";
+ModulePerBaseNContent::ModulePerBaseNContent(const FalcoConfig &config) :
+  Module(ModulePerBaseNContent::module_name) {
   auto grade_n = config.limits.find("n_content")->second;
   grade_n_warn = grade_n.find("warn")->second;
   grade_n_error = grade_n.find("error")->second;
@@ -1392,38 +1384,44 @@ ModulePerBaseNContent::summarize_module(FastqStats &stats) {
     make_linear_base_groups(base_groups, num_bases);
   }
 
-  else make_default_base_groups(base_groups, num_bases);
-  num_groups = base_groups.size();
+  else
+    make_default_base_groups(base_groups, num_bases);
+  num_groups = std::size(base_groups);
 
-  n_pct = vector<double>(num_groups, 0.0);
-  size_t this_n_cnt = 0;
-  size_t this_n_total = 0;
+  n_pct = std::vector<double>(num_groups, 0.0);
+  std::size_t this_n_cnt = 0;
+  std::size_t this_n_total = 0;
   double this_n_pct = 0.0;
 
   max_n_pct = 0.0;
-  for (size_t group = 0; group < num_groups; ++group) {
-    size_t group_n_cnt = 0, group_n_total = 0;
-    for (size_t i = base_groups[group].start;
-                i <= base_groups[group].end; ++i) {
-      this_n_cnt = (i < FastqStats::SHORT_READ_THRESHOLD) ?
-        (stats.n_base_count[i]) : (stats.long_n_base_count[i - FastqStats::SHORT_READ_THRESHOLD]);
-
-      this_n_total = (i < FastqStats::SHORT_READ_THRESHOLD) ? (stats.cumulative_read_length_freq[i]) :
-                     (stats.long_cumulative_read_length_freq[i - FastqStats::SHORT_READ_THRESHOLD]);
-      this_n_pct = this_n_cnt / std::max(num_lim<double>::min(),
+  for (std::size_t group = 0; group < num_groups; ++group) {
+    std::size_t group_n_cnt = 0, group_n_total = 0;
+    for (std::size_t i = base_groups[group].start; i <= base_groups[group].end;
+         ++i) {
+      this_n_cnt =
+        (i < FastqStats::SHORT_READ_THRESHOLD)
+          ? (stats.n_base_count[i])
+          : (stats.long_n_base_count[i - FastqStats::SHORT_READ_THRESHOLD]);
+
+      this_n_total = (i < FastqStats::SHORT_READ_THRESHOLD)
+                       ? (stats.cumulative_read_length_freq[i])
+                       : (stats.long_cumulative_read_length_freq
+                            [i - FastqStats::SHORT_READ_THRESHOLD]);
+      this_n_pct = this_n_cnt / std::max(std::numeric_limits<double>::min(),
                                          static_cast<double>(this_n_total));
-      max_n_pct = max(max_n_pct, this_n_pct);
+      max_n_pct = std::max(max_n_pct, this_n_pct);
       group_n_cnt += this_n_cnt;
       group_n_total += this_n_total;
     }
-    n_pct[group] = 100.0*group_n_cnt / std::max(num_lim<double>::min(),
-                                                static_cast<double>(group_n_total));
+    n_pct[group] = 100.0 * group_n_cnt /
+                   std::max(std::numeric_limits<double>::min(),
+                            static_cast<double>(group_n_total));
   }
 }
 
 void
 ModulePerBaseNContent::make_grade() {
-  if(grade != "fail") {
+  if (grade != "fail") {
     if (max_n_pct > grade_n_error) {
       grade = "fail";
     }
@@ -1435,31 +1433,31 @@ ModulePerBaseNContent::make_grade() {
 }
 
 void
-ModulePerBaseNContent::write_module(ostream &os) {
+ModulePerBaseNContent::write_module(std::ostream &os) {
   os << "#Base\tN-Count\n";
-  for (size_t i = 0; i < num_groups; ++i) {
+  for (std::size_t i = 0; i < num_groups; ++i) {
     os << base_groups[i] << "\t" << n_pct[i] << "\n";
   }
 }
 
-string
+std::string
 ModulePerBaseNContent::make_html_data() {
-  ostringstream data;
+  std::ostringstream data;
   // base position
   data << "{x : [";
-  for (size_t i = 0; i < num_groups; ++i) {
+  for (std::size_t i = 0; i < num_groups; ++i) {
     if (base_groups[i].start == base_groups[i].end)
       data << "\"" << base_groups[i].start + 1 << "\"";
     else
-      data << "\"" << base_groups[i].start + 1 << "-" <<
-                      base_groups[i].end + 1 << "\"";
+      data << "\"" << base_groups[i].start + 1 << "-" << base_groups[i].end + 1
+           << "\"";
     if (i < num_groups - 1)
       data << ", ";
   }
 
   // Y values: frequency with which they were seen
   data << "], y : [";
-  for (size_t i = 0; i < num_groups; ++i) {
+  for (std::size_t i = 0; i < num_groups; ++i) {
     data << n_pct[i];
 
     if (i < num_groups - 1)
@@ -1472,11 +1470,11 @@ ModulePerBaseNContent::make_html_data() {
 }
 
 /************** SEQUENCE LENGTH DISTRIBUTION *****************/
-const string
-ModuleSequenceLengthDistribution::module_name = "Sequence Length Distribution";
-ModuleSequenceLengthDistribution::
-ModuleSequenceLengthDistribution(const FalcoConfig &config) :
-Module(ModuleSequenceLengthDistribution::module_name) {
+const std::string ModuleSequenceLengthDistribution::module_name =
+  "Sequence Length Distribution";
+ModuleSequenceLengthDistribution::ModuleSequenceLengthDistribution(
+  const FalcoConfig &config) :
+  Module(ModuleSequenceLengthDistribution::module_name) {
   auto length_grade = config.limits.find("sequence_length")->second;
   do_grade_error = (length_grade.find("error")->second != 0);
   do_grade_warn = (length_grade.find("warn")->second != 0);
@@ -1489,16 +1487,16 @@ ModuleSequenceLengthDistribution::summarize_module(FastqStats &stats) {
   empty_reads = stats.empty_reads;
   is_all_same_length = true;
   // store the read lengths
-  sequence_lengths = vector<size_t>(max_read_length, 0);
+  sequence_lengths = std::vector<std::size_t>(max_read_length, 0);
 
-  size_t num_nonzero = 0;
-  for (size_t i = 0; i < max_read_length; ++i) {
+  std::size_t num_nonzero = 0;
+  for (std::size_t i = 0; i < max_read_length; ++i) {
     if (i < FastqStats::SHORT_READ_THRESHOLD) {
       sequence_lengths[i] = stats.read_length_freq[i];
-    } else {
-      sequence_lengths[i] = stats.long_read_length_freq[
-                              i - FastqStats::SHORT_READ_THRESHOLD
-                            ];
+    }
+    else {
+      sequence_lengths[i] =
+        stats.long_read_length_freq[i - FastqStats::SHORT_READ_THRESHOLD];
     }
 
     if (sequence_lengths[i] > 0) {
@@ -1524,20 +1522,20 @@ ModuleSequenceLengthDistribution::make_grade() {
 }
 
 void
-ModuleSequenceLengthDistribution::write_module(ostream &os) {
+ModuleSequenceLengthDistribution::write_module(std::ostream &os) {
   os << "#Length\tCount\n";
   if (empty_reads > 0)
     os << "0\t" << empty_reads << ".0\n";
-  for (size_t i = 0; i < max_read_length; ++i) {
+  for (std::size_t i = 0; i < max_read_length; ++i) {
     if (sequence_lengths[i] > 0) {
-      os << i+1 << "\t" << sequence_lengths[i] << ".0\n";
+      os << i + 1 << "\t" << sequence_lengths[i] << ".0\n";
     }
   }
 }
 
-string
+std::string
 ModuleSequenceLengthDistribution::make_html_data() {
-  ostringstream data;
+  std::ostringstream data;
   // X values : avg quality phred scores
   data << "{x : [";
   bool first_seen = false;
@@ -1546,11 +1544,11 @@ ModuleSequenceLengthDistribution::make_html_data() {
     first_seen = true;
     data << "\"0 bp\"";
   }
-  for (size_t i = 0; i < max_read_length; ++i) {
+  for (std::size_t i = 0; i < max_read_length; ++i) {
     if (sequence_lengths[i] > 0) {
       if (first_seen)
         data << ",";
-      data << "\"" << i+1 << " bp\"";
+      data << "\"" << i + 1 << " bp\"";
       first_seen = true;
     }
   }
@@ -1563,7 +1561,7 @@ ModuleSequenceLengthDistribution::make_html_data() {
     first_seen = true;
     data << empty_reads;
   }
-  for (size_t i = 0; i < max_read_length; ++i) {
+  for (std::size_t i = 0; i < max_read_length; ++i) {
     if (sequence_lengths[i] > 0) {
       if (first_seen)
         data << ",";
@@ -1575,11 +1573,11 @@ ModuleSequenceLengthDistribution::make_html_data() {
   // Put the sequence value in the text
   data << "], text : [";
   first_seen = false;
-  for (size_t i = 0; i < max_read_length; ++i) {
+  for (std::size_t i = 0; i < max_read_length; ++i) {
     if (sequence_lengths[i] > 0) {
       if (first_seen)
         data << ",";
-      data << i+1;
+      data << i + 1;
       first_seen = true;
     }
   }
@@ -1592,11 +1590,11 @@ ModuleSequenceLengthDistribution::make_html_data() {
 }
 
 /************** DUPLICATE SEQUENCES **************************/
-const string
-ModuleSequenceDuplicationLevels::module_name = "Sequence Duplication Levels";
-ModuleSequenceDuplicationLevels::
-ModuleSequenceDuplicationLevels(const FalcoConfig &config) :
-Module(ModuleSequenceDuplicationLevels::module_name) {
+const std::string ModuleSequenceDuplicationLevels::module_name =
+  "Sequence Duplication Levels";
+ModuleSequenceDuplicationLevels::ModuleSequenceDuplicationLevels(
+  const FalcoConfig &config) :
+  Module(ModuleSequenceDuplicationLevels::module_name) {
   percentage_deduplicated.fill(0);
   percentage_total.fill(0);
   auto grade_dup = config.limits.find("duplication")->second;
@@ -1606,53 +1604,60 @@ Module(ModuleSequenceDuplicationLevels::module_name) {
 
 void
 ModuleSequenceDuplicationLevels::summarize_module(FastqStats &stats) {
-    seq_total = 0.0;
-    seq_dedup = 0.0;
-
-    // Key is frequenccy (r), value is number of times we saw a sequence
-    // with that frequency (Nr)
-    for (auto v : stats.sequence_count) {
-      if (counts_by_freq.count(v.second) == 0) {
-        counts_by_freq[v.second] = 0;
-      }
-      counts_by_freq[v.second]++;
+  seq_total = 0.0;
+  seq_dedup = 0.0;
+
+  // Key is frequenccy (r), value is number of times we saw a sequence
+  // with that frequency (Nr)
+  for (auto v : stats.sequence_count) {
+    if (counts_by_freq.count(v.second) == 0) {
+      counts_by_freq[v.second] = 0;
     }
+    counts_by_freq[v.second]++;
+  }
 
-    // Now we change it to the FastQC corrected extrapolation
-    for (auto v : counts_by_freq) {
-      counts_by_freq[v.first] =
-      get_corrected_count(stats.count_at_limit, stats.num_reads,
-                          v.first, v.second);
-    }
+  // Now we change it to the FastQC corrected extrapolation
+  for (auto v : counts_by_freq) {
+    counts_by_freq[v.first] = get_corrected_count(
+      stats.count_at_limit, stats.num_reads, v.first, v.second);
+  }
 
-    // Group in blocks similarly to fastqc
-    for (auto v : counts_by_freq) {
-      size_t dup_slot = v.first - 1;
-      if (v.first >= 10000) dup_slot = 15;
-      else if (v.first >= 5000) dup_slot = 14;
-      else if (v.first >= 1000) dup_slot = 13;
-      else if (v.first >= 500) dup_slot = 12;
-      else if (v.first >= 100) dup_slot = 11;
-      else if (v.first >= 50) dup_slot = 10;
-      else if (v.first >= 10) dup_slot = 9;
-
-      percentage_deduplicated[dup_slot] += v.second;
-      percentage_total[dup_slot] += v.second * v.first;
-
-      seq_total += v.second * v.first;
-      seq_dedup += v.second;
-    }
+  // Group in blocks similarly to fastqc
+  for (auto v : counts_by_freq) {
+    std::size_t dup_slot = v.first - 1;
+    if (v.first >= 10000)
+      dup_slot = 15;
+    else if (v.first >= 5000)
+      dup_slot = 14;
+    else if (v.first >= 1000)
+      dup_slot = 13;
+    else if (v.first >= 500)
+      dup_slot = 12;
+    else if (v.first >= 100)
+      dup_slot = 11;
+    else if (v.first >= 50)
+      dup_slot = 10;
+    else if (v.first >= 10)
+      dup_slot = 9;
+
+    percentage_deduplicated[dup_slot] += v.second;
+    percentage_total[dup_slot] += v.second * v.first;
+
+    seq_total += v.second * v.first;
+    seq_dedup += v.second;
+  }
 
-    // "Sequence duplication estimate" in the summary
-    total_deduplicated_pct = 100.0 * seq_dedup / std::max(1.0, seq_total);
+  // "Sequence duplication estimate" in the summary
+  total_deduplicated_pct = 100.0 * seq_dedup / std::max(1.0, seq_total);
 
-    // Convert to percentage
-    for (auto &v : percentage_deduplicated)
-      v = 100.0 * v / std::max(1.0, seq_dedup);  // Percentage of unique sequences in bin
+  // Convert to percentage
+  for (auto &v : percentage_deduplicated)
+    v = 100.0 * v /
+        std::max(1.0, seq_dedup);  // Percentage of unique sequences in bin
 
-     // Convert to percentage
-    for (auto &v : percentage_total)
-      v = 100.0 * v / std::max(1.0, seq_total);  // Percentage of sequences in bin
+  // Convert to percentage
+  for (auto &v : percentage_total)
+    v = 100.0 * v / std::max(1.0, seq_total);  // Percentage of sequences in bin
 }
 
 void
@@ -1668,43 +1673,42 @@ ModuleSequenceDuplicationLevels::make_grade() {
 }
 
 void
-ModuleSequenceDuplicationLevels::write_module(ostream &os) {
-  os << "#Total Deduplicated Percentage\t" <<
-         total_deduplicated_pct << "\n";
+ModuleSequenceDuplicationLevels::write_module(std::ostream &os) {
+  os << "#Total Deduplicated Percentage\t" << total_deduplicated_pct << "\n";
 
   os << "#Duplication Level\tPercentage of deduplicated\t"
      << "Percentage of total\n";
 
-  for (size_t i = 0; i < 9; ++i) {
-    os << i+1 << "\t" << percentage_deduplicated[i] << "\t"
+  for (std::size_t i = 0; i < 9; ++i) {
+    os << i + 1 << "\t" << percentage_deduplicated[i] << "\t"
        << percentage_total[i] << "\n";
   }
 
-  os << ">10\t" << percentage_deduplicated[9]
-     << "\t" << percentage_total[9] << "\n";
-  os << ">50\t" << percentage_deduplicated[10]
-     << "\t" << percentage_total[10] << "\n";
-  os << ">100\t" << percentage_deduplicated[11]
-     << "\t" << percentage_total[11] << "\n";
-  os << ">500\t" << percentage_deduplicated[12]
-     << "\t" << percentage_total[12] << "\n";
-  os << ">1k\t" << percentage_deduplicated[13]
-     << "\t" << percentage_total[13] << "\n";
-  os << ">5k\t" << percentage_deduplicated[14]
-     << "\t" << percentage_total[14] << "\n";
-  os << ">10k+\t" << percentage_deduplicated[15]
-     << "\t" << percentage_total[15] << "\n";
+  os << ">10\t" << percentage_deduplicated[9] << "\t" << percentage_total[9]
+     << "\n";
+  os << ">50\t" << percentage_deduplicated[10] << "\t" << percentage_total[10]
+     << "\n";
+  os << ">100\t" << percentage_deduplicated[11] << "\t" << percentage_total[11]
+     << "\n";
+  os << ">500\t" << percentage_deduplicated[12] << "\t" << percentage_total[12]
+     << "\n";
+  os << ">1k\t" << percentage_deduplicated[13] << "\t" << percentage_total[13]
+     << "\n";
+  os << ">5k\t" << percentage_deduplicated[14] << "\t" << percentage_total[14]
+     << "\n";
+  os << ">10k+\t" << percentage_deduplicated[15] << "\t" << percentage_total[15]
+     << "\n";
 }
 
-string
+std::string
 ModuleSequenceDuplicationLevels::make_html_data() {
-  ostringstream data;
+  std::ostringstream data;
   // non-deduplicated
   data << "{x : [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16]";
 
   // total percentage in each bin
   data << ", y : [";
-  for (size_t i = 0; i < 16; ++i) {
+  for (std::size_t i = 0; i < 16; ++i) {
     data << percentage_total[i];
 
     if (i < 15)
@@ -1716,10 +1720,9 @@ ModuleSequenceDuplicationLevels::make_html_data() {
   // deduplicated
   data << ", {x : [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16]";
 
-
   // total percentage in deduplicated
   data << ", y : [";
-  for (size_t i = 0; i < 16; ++i) {
+  for (std::size_t i = 0; i < 16; ++i) {
     data << percentage_deduplicated[i];
 
     if (i < 15)
@@ -1731,13 +1734,12 @@ ModuleSequenceDuplicationLevels::make_html_data() {
   return data.str();
 }
 
-
 /************** OVERREPRESENTED SEQUENCES ********************/
-const string
-ModuleOverrepresentedSequences::module_name = "Overrepresented sequences";
-ModuleOverrepresentedSequences::
-ModuleOverrepresentedSequences(const FalcoConfig &config) :
-Module(ModuleOverrepresentedSequences::module_name) {
+const std::string ModuleOverrepresentedSequences::module_name =
+  "Overrepresented sequences";
+ModuleOverrepresentedSequences::ModuleOverrepresentedSequences(
+  const FalcoConfig &config) :
+  Module(ModuleOverrepresentedSequences::module_name) {
   contaminants = config.contaminants;
   auto grade_overrep = config.limits.find("overrepresented")->second;
   grade_warn = grade_overrep.find("warn")->second;
@@ -1746,37 +1748,41 @@ Module(ModuleOverrepresentedSequences::module_name) {
 
 // gets the largest suffix of left which is a prefix of right
 // returns 0 if none exist
-size_t
-get_overlap(const string &left, const string &right) {
+std::size_t
+get_overlap(const std::string &left, const std::string &right) {
   const auto left_st(begin(left));
   const auto left_end(end(left));
 
   const auto right_st(begin(right));
   const auto right_end(end(right));
 
-  size_t best = 0;
-  const auto sz = left.size();
-  for (size_t start = 0; start < sz; ++start) {
-    size_t cur = 0;
+  std::size_t best = 0;
+  const auto sz = std::size(left);
+  for (std::size_t start = 0; start < sz; ++start) {
+    std::size_t cur = 0;
     auto left_it(left_st + start);
     auto right_it(right_st);
-    for (; (left_it != left_end) && (right_it != right_end) && (*left_it == *right_it);
-        ++left_it, ++right_it, ++cur);
+    for (; (left_it != left_end) && (right_it != right_end) &&
+           (*left_it == *right_it);
+         ++left_it, ++right_it, ++cur)
+      ;
 
     // does not accept if overlap does not cover a suffix or the
     // entirety of right
     cur = (left_it == left_end || right_it == right_end) ? (cur) : 0;
-    best = max(best, cur);
+    best = std::max(best, cur);
   }
   return best;
 }
 
-string
-ModuleOverrepresentedSequences::get_matching_contaminant (const string &seq) {
-  size_t best = 0;
-  string ret;
+std::string
+ModuleOverrepresentedSequences::get_matching_contaminant(
+  const std::string &seq) {
+  std::size_t best = 0;
+  std::string ret;
   for (auto v : contaminants) {
-    const size_t cand = max(get_overlap(v.second, seq), get_overlap(seq, v.second));
+    const std::size_t cand =
+      std::max(get_overlap(v.second, seq), get_overlap(seq, v.second));
     if (cand > best) {
       best = cand;
       ret = v.first;
@@ -1784,7 +1790,7 @@ ModuleOverrepresentedSequences::get_matching_contaminant (const string &seq) {
   }
 
   // If any sequence is a match, return the best one
-  if (best >= min(ret.size(), seq.size())/2)
+  if (best >= std::min(std::size(ret), std::size(seq)) / 2)
     return ret;
   return "No Hit";
 }
@@ -1793,18 +1799,19 @@ void
 ModuleOverrepresentedSequences::summarize_module(FastqStats &stats) {
   // Keep only sequences that pass the input cutoff
   num_reads = stats.num_reads;
-  for (auto it = stats.sequence_count.begin();
-            it != stats.sequence_count.end(); ++it) {
+  for (auto it = stats.sequence_count.begin(); it != stats.sequence_count.end();
+       ++it) {
     if (it->second > num_reads * min_fraction_to_overrepresented) {
       overrep_sequences.push_back(*it);
     }
   }
 
   // Sort strings by frequency
-  sort(begin(overrep_sequences), end(overrep_sequences),
-       [](const pair<string, size_t> &a, const pair<string, size_t> &b){
-         return a.second > b.second;
-       });
+  std::sort(begin(overrep_sequences), end(overrep_sequences),
+            [](const std::pair<std::string, std::size_t> &a,
+               const std::pair<std::string, std::size_t> &b) {
+              return a.second > b.second;
+            });
 }
 
 void
@@ -1813,7 +1820,8 @@ ModuleOverrepresentedSequences::make_grade() {
     // implment pass warn fail for overrep sequences
     if (grade != "fail") {
       // get percentage that overrep reads represent
-      double pct = 100.0 * seq.second / std::max(static_cast<size_t>(1), num_reads);
+      double pct =
+        100.0 * seq.second / std::max(static_cast<std::size_t>(1), num_reads);
       if (pct > grade_error) {
         grade = "fail";
       }
@@ -1825,22 +1833,22 @@ ModuleOverrepresentedSequences::make_grade() {
 }
 
 void
-ModuleOverrepresentedSequences::write_module(ostream &os) {
-  if (overrep_sequences.size() > 0)
+ModuleOverrepresentedSequences::write_module(std::ostream &os) {
+  if (std::size(overrep_sequences) > 0)
     os << "#Sequence\tCount\tPercentage\tPossible Source\n";
   for (auto seq : overrep_sequences) {
-      os << seq.first << "\t" << seq.second <<  "\t" <<
-        100.0 * seq.second / std::max(static_cast<size_t>(1), num_reads) << "\t"
-        << get_matching_contaminant(seq.first) << "\n";
+    os << seq.first << "\t" << seq.second << "\t"
+       << 100.0 * seq.second / std::max(static_cast<std::size_t>(1), num_reads)
+       << "\t" << get_matching_contaminant(seq.first) << "\n";
   }
 }
 
-string
+std::string
 ModuleOverrepresentedSequences::make_html_data() {
-  if (overrep_sequences.size() == 0) {
+  if (std::size(overrep_sequences) == 0) {
     return "No overrepresented sequences";
   }
-  ostringstream data;
+  std::ostringstream data;
   // Header
   data << "<table><thead><tr>";
   data << "<th>Sequence</th>";
@@ -1853,9 +1861,10 @@ ModuleOverrepresentedSequences::make_html_data() {
   for (auto v : overrep_sequences) {
     data << "<tr><td>" << v.first << "</td>";
     data << "<td>" << v.second << "</td>";
-    data << "<td>" << 100.0 * v.second / std::max(static_cast<size_t>(1), num_reads) << "</td>";
-    data << "<td>" << get_matching_contaminant(v.first)
+    data << "<td>"
+         << 100.0 * v.second / std::max(static_cast<std::size_t>(1), num_reads)
          << "</td>";
+    data << "<td>" << get_matching_contaminant(v.first) << "</td>";
     data << "</tr>";
   }
   data << "</tbody></table>";
@@ -1863,13 +1872,10 @@ ModuleOverrepresentedSequences::make_html_data() {
   return data.str();
 }
 
-
 /************** ADAPTER CONTENT ***********/
-const string
-ModuleAdapterContent::module_name = "Adapter Content";
-ModuleAdapterContent::
-ModuleAdapterContent(const FalcoConfig &config) :
-Module(ModuleAdapterContent::module_name) {
+const std::string ModuleAdapterContent::module_name = "Adapter Content";
+ModuleAdapterContent::ModuleAdapterContent(const FalcoConfig &config) :
+  Module(ModuleAdapterContent::module_name) {
   // data parsed from config
   adapter_names = config.adapter_names;
   adapter_seqs = config.adapter_seqs;
@@ -1877,13 +1883,13 @@ Module(ModuleAdapterContent::module_name) {
   shortest_adapter_size = config.shortest_adapter_size;
 
   // check if they are all the same size
-  if (adapter_names.size() != adapter_seqs.size())
-    throw runtime_error("Adapter name and sequence vector sizes differ");
+  if (std::size(adapter_names) != std::size(adapter_seqs))
+    throw std::runtime_error("Adapter name and sequence vector sizes differ");
 
-  if (adapter_names.size() != adapter_hashes.size())
-    throw runtime_error("Adapter name and hash vector sizes differ");
+  if (std::size(adapter_names) != std::size(adapter_hashes))
+    throw std::runtime_error("Adapter name and hash vector sizes differ");
 
-  num_adapters = adapter_names.size();
+  num_adapters = std::size(adapter_names);
 
   // maximum adapter % before pass/warn/fail
   auto grade_adapter = config.limits.find("adapter")->second;
@@ -1895,36 +1901,40 @@ Module(ModuleAdapterContent::module_name) {
 
 void
 ModuleAdapterContent::summarize_module(FastqStats &stats) {
-  num_bases = max(min(stats.max_read_length, FastqStats::SHORT_READ_THRESHOLD),
-                  ((shortest_adapter_size >= 1) ? (shortest_adapter_size - 1) : 0));
+  num_bases =
+    std::max(std::min(stats.max_read_length, FastqStats::SHORT_READ_THRESHOLD),
+             ((shortest_adapter_size >= 1) ? (shortest_adapter_size - 1) : 0));
 
-  if (num_bases + 1 >= shortest_adapter_size) { // otherwise this module does not make sense
+  if (num_bases + 1 >=
+      shortest_adapter_size) {  // otherwise this module does not make sense
     adapter_pos_pct.clear();
-    for (size_t i = 0; i < num_adapters; ++i)
+    for (std::size_t i = 0; i < num_adapters; ++i)
       adapter_pos_pct.push_back(
-          vector<double>(num_bases - shortest_adapter_size + 1, 0.0)
-      );
+        std::vector<double>(num_bases - shortest_adapter_size + 1, 0.0));
 
-    size_t cnt = 0;
-    for (size_t i = 0; i < adapter_pos_pct.size(); ++i) {
-      for (size_t j = 0; j < adapter_pos_pct[0].size(); ++j) {
+    std::size_t cnt = 0;
+    for (std::size_t i = 0; i < std::size(adapter_pos_pct); ++i) {
+      for (std::size_t j = 0; j < std::size(adapter_pos_pct[0]); ++j) {
         cnt = 0;
         // check if position even makes sense
-        if (j + adapter_seqs[i].size() < num_bases + 1 && j + adapter_seqs[i].size() >= 1)
-          cnt = stats.pos_adapter_count[
-            ((j + adapter_seqs[i].size() - 1) << stats.kBitShiftAdapter) | i
-          ];
-
-        if (j == 0) adapter_pos_pct[i][j] = cnt;
-        else adapter_pos_pct[i][j] = adapter_pos_pct[i][j-1] + cnt;
+        if (j + std::size(adapter_seqs[i]) < num_bases + 1 &&
+            j + std::size(adapter_seqs[i]) >= 1)
+          cnt = stats.pos_adapter_count[((j + std::size(adapter_seqs[i]) - 1)
+                                         << stats.kBitShiftAdapter) |
+                                        i];
+
+        if (j == 0)
+          adapter_pos_pct[i][j] = cnt;
+        else
+          adapter_pos_pct[i][j] = adapter_pos_pct[i][j - 1] + cnt;
       }
     }
 
     // now convert the counts we got before to percentage
-    for (size_t i = 0; i < adapter_pos_pct.size(); ++i) {
-      for (size_t j = 0; j < adapter_pos_pct[0].size(); ++j) {
+    for (std::size_t i = 0; i < std::size(adapter_pos_pct); ++i) {
+      for (std::size_t j = 0; j < std::size(adapter_pos_pct[0]); ++j) {
         adapter_pos_pct[i][j] *= 100.0;
-        adapter_pos_pct[i][j] /= std::max(num_lim<double>::min(),
+        adapter_pos_pct[i][j] /= std::max(std::numeric_limits<double>::min(),
                                           static_cast<double>(stats.num_reads));
       }
     }
@@ -1933,12 +1943,13 @@ ModuleAdapterContent::summarize_module(FastqStats &stats) {
 
 void
 ModuleAdapterContent::make_grade() {
-  for (size_t i = 0; i < adapter_pos_pct.size(); ++i) {
-    for (size_t j = 0; j < adapter_pos_pct[0].size(); ++j) {
+  for (std::size_t i = 0; i < std::size(adapter_pos_pct); ++i) {
+    for (std::size_t j = 0; j < std::size(adapter_pos_pct[0]); ++j) {
       if (grade != "fail") {
         if (adapter_pos_pct[i][j] > grade_error) {
           grade = "fail";
-        } else if (adapter_pos_pct[i][j] > grade_warn) {
+        }
+        else if (adapter_pos_pct[i][j] > grade_warn) {
           grade = "warn";
         }
       }
@@ -1947,29 +1958,29 @@ ModuleAdapterContent::make_grade() {
 }
 
 void
-ModuleAdapterContent::write_module(ostream &os) {
+ModuleAdapterContent::write_module(std::ostream &os) {
   // ADS: number of positions with data calculated
-  const size_t n_pos_calc =
-    (adapter_pos_pct.empty() ? 0 : adapter_pos_pct[0].size());
+  const std::size_t n_pos_calc =
+    (adapter_pos_pct.empty() ? 0 : std::size(adapter_pos_pct[0]));
 
   os << "#Position";
 
   // adapter names
-  for (size_t i = 0; i < num_adapters; ++i)
+  for (std::size_t i = 0; i < num_adapters; ++i)
     os << "\t" << adapter_names[i];
   os << "\n";
 
   // matrix of percentages
-  for (size_t i = 0; i < n_pos_calc; ++i) {
+  for (std::size_t i = 0; i < n_pos_calc; ++i) {
     os << i + 1;
-    for (size_t j = 0; j < num_adapters; ++j)
+    for (std::size_t j = 0; j < num_adapters; ++j)
       os << "\t" << adapter_pos_pct[j][i];
     os << "\n";
   }
   // ADS: now be sure to print the full read length
-  for (size_t i = n_pos_calc; i < num_bases; ++i) {
+  for (std::size_t i = n_pos_calc; i < num_bases; ++i) {
     os << i + 1;
-    for (size_t j = 0; j < num_adapters; ++j)
+    for (std::size_t j = 0; j < num_adapters; ++j)
       // ADS: since this is cumulative, pad with final entry; but only
       // if that exists...
       if (!adapter_pos_pct[j].empty())
@@ -1978,16 +1989,16 @@ ModuleAdapterContent::write_module(ostream &os) {
   }
 }
 
-string
+std::string
 ModuleAdapterContent::make_html_data() {
   bool seen_first = false;
-  ostringstream data;
+  std::ostringstream data;
 
   // ADS: number of positions with data calculated
-  const size_t n_pos_calc =
-    (adapter_pos_pct.empty() ? 0 : adapter_pos_pct[0].size());
+  const std::size_t n_pos_calc =
+    (adapter_pos_pct.empty() ? 0 : std::size(adapter_pos_pct[0]));
 
-  for (size_t i = 0; i < num_adapters; ++i) {
+  for (std::size_t i = 0; i < num_adapters; ++i) {
     if (!seen_first) {
       seen_first = true;
     }
@@ -1998,19 +2009,21 @@ ModuleAdapterContent::make_html_data() {
 
     // X values : read position
     data << "x : [";
-    for (size_t j = 0; j < n_pos_calc; ++j) {
-      data << j+1;
-      if (j + 1 < num_bases) data << ",";
+    for (std::size_t j = 0; j < n_pos_calc; ++j) {
+      data << j + 1;
+      if (j + 1 < num_bases)
+        data << ",";
     }
-    for (size_t j = n_pos_calc; j < num_bases; ++j) {
-      data << j+1;
-      if (j + 1 < num_bases) data << ",";
+    for (std::size_t j = n_pos_calc; j < num_bases; ++j) {
+      data << j + 1;
+      if (j + 1 < num_bases)
+        data << ",";
     }
     data << "]";
 
     // Y values : cumulative adapter frequency
     data << ", y : [";
-    for (size_t j = 0; j < n_pos_calc; ++j) {
+    for (std::size_t j = 0; j < n_pos_calc; ++j) {
       data << adapter_pos_pct[i][j];
       if (j + 1 < num_bases)
         data << ",";
@@ -2019,7 +2032,7 @@ ModuleAdapterContent::make_html_data() {
     // percentage if that exists. I don't know how we could get here
     // if it doesn't, but it's happening.
     if (!adapter_pos_pct[i].empty()) {
-      for (size_t j = n_pos_calc; j < num_bases; ++j) {
+      for (std::size_t j = n_pos_calc; j < num_bases; ++j) {
         data << adapter_pos_pct[i].back();
         if (j + 1 < num_bases)
           data << ",";
@@ -2034,20 +2047,18 @@ ModuleAdapterContent::make_html_data() {
 }
 
 /************** KMER CONTENT ******************************/
-const string
-ModuleKmerContent::module_name = "Kmer Content";
+const std::string ModuleKmerContent::module_name = "Kmer Content";
 
 // ADS: Defining const static integer class variables here for
 // correctness. Optimizer has been ignoring the issue. Hopefully it
 // still will when turned on, and allow non-optimized code for
 // debugging to compile.
-const size_t ModuleKmerContent::MIN_OBS_EXP_TO_REPORT;
-const size_t ModuleKmerContent::MAX_KMERS_TO_REPORT;
-const size_t ModuleKmerContent::MAX_KMERS_TO_PLOT;
+const std::size_t ModuleKmerContent::MIN_OBS_EXP_TO_REPORT;
+const std::size_t ModuleKmerContent::MAX_KMERS_TO_REPORT;
+const std::size_t ModuleKmerContent::MAX_KMERS_TO_PLOT;
 
-ModuleKmerContent::
-ModuleKmerContent(const FalcoConfig &config) :
-Module(ModuleKmerContent::module_name) {
+ModuleKmerContent::ModuleKmerContent(const FalcoConfig &config) :
+  Module(ModuleKmerContent::module_name) {
   auto grade_kmer = config.limits.find("kmer")->second;
   grade_warn = grade_kmer.find("warn")->second;
   grade_error = grade_kmer.find("error")->second;
@@ -2068,36 +2079,38 @@ ModuleKmerContent::summarize_module(FastqStats &stats) {
   pos_kmer_count = stats.pos_kmer_count;
 
   // Allocates space for all statistics
-  obs_exp_max = vector<double>(num_kmers, 0.0);
-  where_obs_exp_is_max = vector<size_t>(num_kmers, 0);
-  total_kmer_counts = vector<size_t>(num_kmers, 0);
+  obs_exp_max = std::vector<double>(num_kmers, 0.0);
+  where_obs_exp_is_max = std::vector<std::size_t>(num_kmers, 0);
+  total_kmer_counts = std::vector<std::size_t>(num_kmers, 0);
 
   // temp variables
-  size_t observed_count;
+  std::size_t observed_count;
   double expected_count;
   double obs_exp_ratio;
   num_seen_kmers = 0;
 
   // Here we get the total count of all kmers and the number of observed kmers
-  for (size_t kmer = 0; kmer < num_kmers; ++kmer) {
-    for (size_t i = kmer_size - 1; i < num_kmer_bases; ++i) {
-      observed_count = stats.kmer_count[
-                          (i << Constants::bit_shift_kmer) | kmer
-                       ];
+  for (std::size_t kmer = 0; kmer < num_kmers; ++kmer) {
+    for (std::size_t i = kmer_size - 1; i < num_kmer_bases; ++i) {
+      observed_count =
+        stats.kmer_count[(i << Constants::bit_shift_kmer) | kmer];
       total_kmer_counts[kmer] += observed_count;
     }
-    if (total_kmer_counts[kmer] > 0) ++num_seen_kmers;
+    if (total_kmer_counts[kmer] > 0)
+      ++num_seen_kmers;
   }
 
   double dividend = static_cast<double>(num_seen_kmers);
-  for (size_t kmer = 0; kmer < num_kmers; ++kmer) {
-    for (size_t i = kmer_size - 1; i < num_kmer_bases; ++i) {
+  for (std::size_t kmer = 0; kmer < num_kmers; ++kmer) {
+    for (std::size_t i = kmer_size - 1; i < num_kmer_bases; ++i) {
       observed_count =
         stats.kmer_count[(i << Constants::bit_shift_kmer) | kmer];
 
-      expected_count = pos_kmer_count[i] / std::max(num_lim<double>::min(), dividend);
+      expected_count = pos_kmer_count[i] /
+                       std::max(std::numeric_limits<double>::min(), dividend);
       // ADS: below, denom can't be zero if not above?
-      obs_exp_ratio = (expected_count > 0) ? (observed_count / expected_count) : 0;
+      obs_exp_ratio =
+        (expected_count > 0) ? (observed_count / expected_count) : 0;
 
       if (i == 0 || obs_exp_ratio > obs_exp_max[kmer]) {
         obs_exp_max[kmer] = obs_exp_ratio;
@@ -2106,24 +2119,26 @@ ModuleKmerContent::summarize_module(FastqStats &stats) {
     }
 
     if (obs_exp_max[kmer] > MIN_OBS_EXP_TO_REPORT) {
-      kmers_to_report.push_back(make_pair(kmer, obs_exp_max[kmer]));
+      kmers_to_report.push_back(std::make_pair(kmer, obs_exp_max[kmer]));
     }
   }
 
-  sort (begin(kmers_to_report), end(kmers_to_report),
-        [](const pair<size_t, double> &a, const pair<size_t, double> &b) {
-          return a.second > b.second;
-        });
+  std::sort(begin(kmers_to_report), end(kmers_to_report),
+            [](const std::pair<std::size_t, double> &a,
+               const std::pair<std::size_t, double> &b) {
+              return a.second > b.second;
+            });
 }
 
 void
 ModuleKmerContent::make_grade() {
-  const size_t lim = min(kmers_to_report.size(), MAX_KMERS_TO_REPORT);
+  const std::size_t lim =
+    std::min(std::size(kmers_to_report), MAX_KMERS_TO_REPORT);
   grade = "pass";
 
   // the worst kmer is at the top
   if (lim > 0) {
-    const size_t kmer = kmers_to_report[0].first;
+    const std::size_t kmer = kmers_to_report[0].first;
     const double obs_exp = obs_exp_max[kmer];
     if (obs_exp >= grade_error)
       grade = "fail";
@@ -2133,39 +2148,38 @@ ModuleKmerContent::make_grade() {
 }
 
 void
-ModuleKmerContent::write_module(ostream &os) {
-  os << "#Sequence" << '\t'
-     << "Count" << '\t'
-     << "PValue" << '\t'
-     << "Obs/Exp Max" << '\t'
-     << "Max Obs/Exp Position" << '\n';
-  const size_t lim = min(kmers_to_report.size(), MAX_KMERS_TO_REPORT);
-  for (size_t i = 0; i < lim; ++i) {
-    const size_t kmer = kmers_to_report[i].first;
-    os << size_t_to_seq(kmer, kmer_size) << "\t"
-       << total_kmer_counts[kmer] << "\t"
-       << "0.0" << "\t"
-       << obs_exp_max[kmer] << "\t"
+ModuleKmerContent::write_module(std::ostream &os) {
+  os << "#Sequence" << '\t' << "Count" << '\t' << "PValue" << '\t'
+     << "Obs/Exp Max" << '\t' << "Max Obs/Exp Position" << '\n';
+  const std::size_t lim =
+    std::min(std::size(kmers_to_report), MAX_KMERS_TO_REPORT);
+  for (std::size_t i = 0; i < lim; ++i) {
+    const std::size_t kmer = kmers_to_report[i].first;
+    os << size_t_to_seq(kmer, kmer_size) << "\t" << total_kmer_counts[kmer]
+       << "\t"
+       << "0.0" << "\t" << obs_exp_max[kmer] << "\t"
        << where_obs_exp_is_max[kmer] << "\n";
   }
 }
 
-string
+std::string
 ModuleKmerContent::make_html_data() {
   bool seen_first = false;
-  ostringstream data;
-  const size_t lim = min(kmers_to_report.size(), MAX_KMERS_TO_PLOT);
+  std::ostringstream data;
+  const std::size_t lim =
+    std::min(std::size(kmers_to_report), MAX_KMERS_TO_PLOT);
 
   // get xlim to plot: whatever the largest position with some
   // reported k-mer is
-  size_t xlim = 0;
-  for (size_t i = 0; i < lim; ++i)
-    xlim = max(xlim, where_obs_exp_is_max[kmers_to_report[i].first]);
+  std::size_t xlim = 0;
+  for (std::size_t i = 0; i < lim; ++i)
+    xlim = std::max(xlim, where_obs_exp_is_max[kmers_to_report[i].first]);
   xlim += kmer_size;
 
-  for (size_t i = 0; i < lim; ++i) {
-    const size_t kmer = kmers_to_report[i].first;
-    const double log_obs_exp = log(kmers_to_report[i].second)/log(2.0);
+  for (std::size_t i = 0; i < lim; ++i) {
+    const std::size_t kmer = kmers_to_report[i].first;
+    const double log_obs_exp =
+      std::log(kmers_to_report[i].second) / std::log(2.0);
     if (!seen_first)
       seen_first = true;
     else
@@ -2174,16 +2188,17 @@ ModuleKmerContent::make_html_data() {
 
     // X values : read position
     data << "x : [";
-    for (size_t j = 0; j < xlim; ++j) {
-      data << j+1;
-      if (j < xlim - 1) data << ",";
+    for (std::size_t j = 0; j < xlim; ++j) {
+      data << j + 1;
+      if (j < xlim - 1)
+        data << ",";
     }
     data << "]";
 
     // Y values : A peak wherever the k-mer is seen the most
     data << ", y : [";
-    for (size_t j = 0; j < xlim; ++j) {
-      data << ((j == (where_obs_exp_is_max[kmer])) ? (log_obs_exp) : 0);
+    for (std::size_t j = 0; j < xlim; ++j) {
+      data << ((j == where_obs_exp_is_max[kmer]) ? log_obs_exp : 0);
       if (j < xlim - 1)
         data << ",";
     }
diff --git a/src/Module.hpp b/src/Module.hpp
index dcceb51..511edd1 100644
--- a/src/Module.hpp
+++ b/src/Module.hpp
@@ -1,4 +1,4 @@
-/* 
+/*
  * Copyright (C) 2019 Guilherme De Sena Brandine and
  *                    Andrew D. Smith
  * Authors: Guilherme De Sena Brandine, Andrew Smith
@@ -14,31 +14,29 @@
  * General Public License for more details.
  */
 
-
 #ifndef _MODULE_CPP
 #define _MODULE_CPP
-#include "FastqStats.hpp"
 #include "FalcoConfig.hpp"
+#include "FastqStats.hpp"
 #include "HtmlMaker.hpp"
-#include <string>
 #include <iostream>
 #include <string>
-#include <vector>
 #include <unordered_map>
 #include <unordered_set>
 #include <utility>
+#include <vector>
 
 /* base groups for longer reads, copied from FastQC*/
 struct BaseGroup {
-  size_t start,end;
-  BaseGroup (size_t _start, size_t _end) : start(_start), end(_end) {}
+  size_t start, end;
+  BaseGroup(size_t _start, size_t _end) : start(_start), end(_end) {}
 };
 
-
 class Module {
- private:
+private:
   const std::string module_name;
- public:
+
+public:
   // avoid writing things prior to summarizing
   bool summarized;
 
@@ -66,7 +64,7 @@ class Module {
   std::string grade;
 
   std::string html_data;
-  Module(const std::string &_module_name);
+  Module(const std::string &module_name);
   virtual ~Module() = 0;
 
   /*********************************************/
@@ -74,34 +72,42 @@ class Module {
   /*********************************************/
 
   // Summarize the module
-  virtual void summarize_module(FastqStats &stats) = 0;
+  virtual void
+  summarize_module(FastqStats &stats) = 0;
 
   // Decide if it's a pass/warn/fail
-  virtual void make_grade() = 0;
+  virtual void
+  make_grade() = 0;
 
   // write long summary
-  virtual void write_module(std::ostream &os) = 0;
-  virtual std::string make_html_data() = 0;
+  virtual void
+  write_module(std::ostream &os) = 0;
+  virtual std::string
+  make_html_data() = 0;
 
   /*********************************************/
   /**************Visible functions**************/
   /*********************************************/
   // Summarizes and registers that it summarized
-  void summarize(FastqStats &stats);
+  void
+  summarize(FastqStats &stats);
 
   // Write the module in the FastQC standard, starting with title,
   // pass/warn/fail and then ending with >>END_MODULE
-  void write(std::ostream &os);
+  void
+  write(std::ostream &os);
 
   // write short summary
-  void write_short_summary(std::ostream &os, const std::string &filename);
+  void
+  write_short_summary(std::ostream &os, const std::string &filename);
 
   // Put html data
-  void put_data_on_html(HtmlMaker &html_maker);
+  void
+  put_data_on_html(HtmlMaker &html_maker);
 };
 
 class ModuleBasicStatistics : public Module {
- public:
+public:
   bool is_nanopore;
   std::string file_type;
   std::string file_encoding;
@@ -115,78 +121,92 @@ class ModuleBasicStatistics : public Module {
   static const std::string module_name;
   ModuleBasicStatistics(const FalcoConfig &config);
   ~ModuleBasicStatistics() {}
-  void summarize_module(FastqStats &stats);
-  void make_grade();
-  void write_module(std::ostream &os);
-  std::string make_html_data();
-
-  void read_data_line(const std::string &line);
+  void
+  summarize_module(FastqStats &stats);
+  void
+  make_grade();
+  void
+  write_module(std::ostream &os);
+  std::string
+  make_html_data();
+
+  void
+  read_data_line(const std::string &line);
 };
 
 class ModulePerBaseSequenceQuality : public Module {
- private:
+private:
   // from FastQC: whether to group bases
   bool do_group;
   size_t num_bases;
   size_t num_groups;
   // grade criteria
-  size_t base_lower_warn,
-         base_lower_error,
-         base_median_warn,
-         base_median_error;
+  size_t base_lower_warn, base_lower_error, base_median_warn, base_median_error;
   size_t num_warn, num_error;
   std::vector<double> group_mean;
-  std::vector<double> group_ldecile,
-                      group_lquartile,
-                      group_median,
-                      group_uquartile,
-                      group_udecile;
+  std::vector<double> group_ldecile, group_lquartile, group_median,
+    group_uquartile, group_udecile;
   std::vector<BaseGroup> base_groups;
 
- public:
+public:
   static const std::string module_name;
   ModulePerBaseSequenceQuality(const FalcoConfig &config);
   ~ModulePerBaseSequenceQuality() {}
-  void summarize_module(FastqStats &stats);
-  void make_grade();
-  void write_module(std::ostream &os);
-  void read_data_line(const std::string &line);
-  std::string make_html_data();
+  void
+  summarize_module(FastqStats &stats);
+  void
+  make_grade();
+  void
+  write_module(std::ostream &os);
+  void
+  read_data_line(const std::string &line);
+  std::string
+  make_html_data();
 };
 
 class ModulePerTileSequenceQuality : public Module {
- private:
-   double grade_warn, grade_error;
-   size_t max_read_length;
-   std::unordered_map<size_t, std::vector<double>> tile_position_quality;
-   std::vector<size_t> tiles_sorted;
- public:
+private:
+  double grade_warn, grade_error;
+  size_t max_read_length;
+  std::unordered_map<size_t, std::vector<double>> tile_position_quality;
+  std::vector<size_t> tiles_sorted;
+
+public:
   static const std::string module_name;
   ModulePerTileSequenceQuality(const FalcoConfig &config);
   ~ModulePerTileSequenceQuality() {}
-  void summarize_module(FastqStats &stats);
-  void make_grade();
-  void write_module(std::ostream &os);
-  std::string make_html_data();
+  void
+  summarize_module(FastqStats &stats);
+  void
+  make_grade();
+  void
+  write_module(std::ostream &os);
+  std::string
+  make_html_data();
 };
 
 class ModulePerSequenceQualityScores : public Module {
- private:
-   size_t mode_val;
-   size_t mode_ind;
-   size_t offset;
-   std::array<size_t, FastqStats::kNumQualityValues> quality_count;
-   // grade criteria
-   size_t mode_warn;
-   size_t mode_error;
- public:
+private:
+  size_t mode_val;
+  size_t mode_ind;
+  size_t offset;
+  std::array<size_t, FastqStats::kNumQualityValues> quality_count;
+  // grade criteria
+  size_t mode_warn;
+  size_t mode_error;
+
+public:
   static const std::string module_name;
   ModulePerSequenceQualityScores(const FalcoConfig &config);
   ~ModulePerSequenceQualityScores() {}
-  void summarize_module(FastqStats &stats);
-  void make_grade();
-  void write_module(std::ostream &os);
-  std::string make_html_data();
+  void
+  summarize_module(FastqStats &stats);
+  void
+  make_grade();
+  void
+  write_module(std::ostream &os);
+  std::string
+  make_html_data();
 };
 
 class ModulePerBaseSequenceContent : public Module {
@@ -207,31 +227,40 @@ class ModulePerBaseSequenceContent : public Module {
 
   size_t num_groups;
   std::vector<BaseGroup> base_groups;
- public:
+
+public:
   static const std::string module_name;
   ModulePerBaseSequenceContent(const FalcoConfig &config);
   ~ModulePerBaseSequenceContent() {}
-  void summarize_module(FastqStats &stats);
-  void make_grade();
-  void write_module(std::ostream &os);
-  std::string make_html_data();
+  void
+  summarize_module(FastqStats &stats);
+  void
+  make_grade();
+  void
+  write_module(std::ostream &os);
+  std::string
+  make_html_data();
 };
 
 class ModulePerSequenceGCContent : public Module {
- private:
-   double gc_warn, gc_error;
-   double gc_deviation;
-   std::array<double, 101> gc_count;
-   std::array<double, 101> theoretical_gc_count;
+private:
+  double gc_warn, gc_error;
+  double gc_deviation;
+  std::array<double, 101> gc_count;
+  std::array<double, 101> theoretical_gc_count;
 
- public:
+public:
   static const std::string module_name;
   ModulePerSequenceGCContent(const FalcoConfig &config);
   ~ModulePerSequenceGCContent() {}
-  void summarize_module(FastqStats &stats);
-  void make_grade();
-  void write_module(std::ostream &os);
-  std::string make_html_data();
+  void
+  summarize_module(FastqStats &stats);
+  void
+  make_grade();
+  void
+  write_module(std::ostream &os);
+  std::string
+  make_html_data();
 };
 
 class ModulePerBaseNContent : public Module {
@@ -251,18 +280,23 @@ class ModulePerBaseNContent : public Module {
   bool do_group;
   size_t num_groups;
   std::vector<BaseGroup> base_groups;
- public:
+
+public:
   static const std::string module_name;
   ModulePerBaseNContent(const FalcoConfig &config);
   ~ModulePerBaseNContent() {}
-  void summarize_module(FastqStats &stats);
-  void make_grade();
-  void write_module(std::ostream &os);
-  std::string make_html_data();
+  void
+  summarize_module(FastqStats &stats);
+  void
+  make_grade();
+  void
+  write_module(std::ostream &os);
+  std::string
+  make_html_data();
 };
 
 class ModuleSequenceLengthDistribution : public Module {
- private:
+private:
   bool do_grade_error;
   bool do_grade_warn;
   size_t max_read_length;
@@ -275,118 +309,142 @@ class ModuleSequenceLengthDistribution : public Module {
   bool do_group;
   size_t num_groups;
   std::vector<BaseGroup> base_groups;
- public:
+
+public:
   static const std::string module_name;
   ModuleSequenceLengthDistribution(const FalcoConfig &config);
   ~ModuleSequenceLengthDistribution() {}
-  void summarize_module(FastqStats &stats);
-  void make_grade();
-  void write_module(std::ostream &os);
-  std::string make_html_data();
+  void
+  summarize_module(FastqStats &stats);
+  void
+  make_grade();
+  void
+  write_module(std::ostream &os);
+  std::string
+  make_html_data();
 };
 
 class ModuleSequenceDuplicationLevels : public Module {
- private:
-   double seq_total, seq_dedup;
-
-   double grade_dup_warn;
-   double grade_dup_error;
-   double total_deduplicated_pct;
-   std::array<double, 16> percentage_deduplicated;
-   std::array<double, 16> percentage_total;
-   std::unordered_map<size_t,size_t> counts_by_freq;
- public:
+private:
+  double seq_total, seq_dedup;
+
+  double grade_dup_warn;
+  double grade_dup_error;
+  double total_deduplicated_pct;
+  std::array<double, 16> percentage_deduplicated;
+  std::array<double, 16> percentage_total;
+  std::unordered_map<size_t, size_t> counts_by_freq;
+
+public:
   static const std::string module_name;
   ModuleSequenceDuplicationLevels(const FalcoConfig &config);
   ~ModuleSequenceDuplicationLevels() {}
-  void summarize_module(FastqStats &stats);
-  void make_grade();
-  void write_module(std::ostream &os);
-  std::string make_html_data();
+  void
+  summarize_module(FastqStats &stats);
+  void
+  make_grade();
+  void
+  write_module(std::ostream &os);
+  std::string
+  make_html_data();
 };
 
 class ModuleOverrepresentedSequences : public Module {
- private:
+private:
   size_t num_reads;
   std::vector<std::pair<std::string, size_t>> overrep_sequences;
   double grade_warn, grade_error;
   const double min_fraction_to_overrepresented = 0.001;
-  std::vector<std::pair<std::string, std::string> > contaminants;
+  std::vector<std::pair<std::string, std::string>> contaminants;
 
   // Function to find the matching contaminant within the list
-  std::string get_matching_contaminant(const std::string &seq);
- public:
+  std::string
+  get_matching_contaminant(const std::string &seq);
+
+public:
   static const std::string module_name;
   ModuleOverrepresentedSequences(const FalcoConfig &config);
   ~ModuleOverrepresentedSequences() {}
-  void summarize_module(FastqStats &stats);
-  void make_grade();
-  void write_module(std::ostream &os);
-  std::string make_html_data();
+  void
+  summarize_module(FastqStats &stats);
+  void
+  make_grade();
+  void
+  write_module(std::ostream &os);
+  std::string
+  make_html_data();
 };
 
 class ModuleAdapterContent : public Module {
- private:
-   // Number of adapters to test
-   size_t num_adapters;
-
-   // number of bases to report
-   size_t num_bases;
-
-   // adapter size to know how many bases to report
-   size_t adapter_size;
-
-   // Information from config
-   std::vector<std::string> adapter_names;
-   std::vector<std::string> adapter_seqs;
-   std::vector<size_t> adapter_hashes;
-   size_t shortest_adapter_size;
-
-   // vector to be reported
-   std::vector<std::vector<double>> adapter_pos_pct;
-   // minimum percentages for warn/fail
-   double grade_warn, grade_error;
-
-   // Aux function to count adapter in a position
-   double count_adapter (const std::vector<size_t> &kmer_count,
-                         const size_t pos,
-                         const size_t adapter_hash,
-                         const size_t adapter_size,
-                         const size_t kmer_size);
- public:
+private:
+  // Number of adapters to test
+  size_t num_adapters;
+
+  // number of bases to report
+  size_t num_bases;
+
+  // adapter size to know how many bases to report
+  size_t adapter_size;
+
+  // Information from config
+  std::vector<std::string> adapter_names;
+  std::vector<std::string> adapter_seqs;
+  std::vector<size_t> adapter_hashes;
+  size_t shortest_adapter_size;
+
+  // vector to be reported
+  std::vector<std::vector<double>> adapter_pos_pct;
+  // minimum percentages for warn/fail
+  double grade_warn, grade_error;
+
+  // Aux function to count adapter in a position
+  double
+  count_adapter(const std::vector<size_t> &kmer_count, const size_t pos,
+                const size_t adapter_hash, const size_t adapter_size,
+                const size_t kmer_size);
+
+public:
   static const std::string module_name;
   ModuleAdapterContent(const FalcoConfig &config);
   ~ModuleAdapterContent() {}
-  void summarize_module(FastqStats &stats);
-  void make_grade();
-  void write_module(std::ostream &os);
-  std::string make_html_data();
+  void
+  summarize_module(FastqStats &stats);
+  void
+  make_grade();
+  void
+  write_module(std::ostream &os);
+  std::string
+  make_html_data();
 };
 
 class ModuleKmerContent : public Module {
- private:
-   size_t num_kmer_bases;
-   size_t kmer_size;
-   size_t num_kmers;
-   size_t num_seen_kmers;
-
-   double grade_warn, grade_error;
-   std::array<size_t, FastqStats::SHORT_READ_THRESHOLD> pos_kmer_count;
-   std::vector<size_t> total_kmer_counts;
-   std::vector<double> obs_exp_max;
-   std::vector<size_t> where_obs_exp_is_max;
-   std::vector<std::pair<size_t, double>> kmers_to_report;
- public:
+private:
+  size_t num_kmer_bases;
+  size_t kmer_size;
+  size_t num_kmers;
+  size_t num_seen_kmers;
+
+  double grade_warn, grade_error;
+  std::array<size_t, FastqStats::SHORT_READ_THRESHOLD> pos_kmer_count;
+  std::vector<size_t> total_kmer_counts;
+  std::vector<double> obs_exp_max;
+  std::vector<size_t> where_obs_exp_is_max;
+  std::vector<std::pair<size_t, double>> kmers_to_report;
+
+public:
   static const std::string module_name;
   static const size_t MIN_OBS_EXP_TO_REPORT = 5;
   static const size_t MAX_KMERS_TO_REPORT = 20;
   static const size_t MAX_KMERS_TO_PLOT = 10;
   ModuleKmerContent(const FalcoConfig &config);
-  ~ModuleKmerContent(){}
-  void summarize_module(FastqStats &stats);
-  void make_grade();
-  void write_module(std::ostream &os);
-  std::string make_html_data();
+  ~ModuleKmerContent() {}
+  void
+  summarize_module(FastqStats &stats);
+  void
+  make_grade();
+  void
+  write_module(std::ostream &os);
+  std::string
+  make_html_data();
 };
 #endif
-
diff --git a/src/StreamReader.cpp b/src/StreamReader.cpp
index b964f12..fb1f769 100644
--- a/src/StreamReader.cpp
+++ b/src/StreamReader.cpp
@@ -14,24 +14,17 @@
  */
 
 #include "StreamReader.hpp"
-#include <vector>
-#include <cstring>
+
 #include <algorithm>
+#include <cstring>
 #include <fstream>
-
-using std::cerr;
-using std::ifstream;
-using std::min;
-using std::string;
-using std::vector;
-using std::runtime_error;
-using std::array;
-using std::end;
-using std::getline;
+#include <string>
+#include <vector>
 
 // this is faster than std::min
-template<class T>
-inline T min8(const T a, const T b) {
+template <class T>
+inline T
+min8(const T a, const T b) {
   return (a < b) ? a : b;
 }
 /****************************************************/
@@ -39,36 +32,38 @@ inline T min8(const T a, const T b) {
 /****************************************************/
 size_t
 get_tile_split_position(FalcoConfig &config) {
-  const std::string& filename = config.filename;
+  const std::string &filename = config.filename;
   // Count colons to know the formatting pattern
   size_t num_colon = 0;
 
   if (config.is_sam) {
-    ifstream sam_file(filename);
+    std::ifstream sam_file(filename);
     if (!sam_file)
-      throw runtime_error("cannot load sam file : " + filename);
-    string line;
-    while (getline(sam_file, line) && line.size() > 0 && line[0] == '@')
+      throw std::runtime_error("cannot load sam file : " + filename);
+    std::string line;
+    while (std::getline(sam_file, line) && line.size() > 0 && line[0] == '@')
       continue;
     size_t tabPos = line.find('\t');
     line = line.substr(0, tabPos);
-    for (char c : line) num_colon += (c == ':');
+    for (char c : line)
+      num_colon += (c == ':');
   }
 #ifdef USE_HTS
   else if (config.is_bam) {
-    htsFile *hts = hts_open(filename.c_str(), "r");
+    htsFile *hts = hts_open(std::data(filename), "r");
     if (!hts)
-      throw runtime_error("cannot load bam file : " + filename);
+      throw std::runtime_error("cannot load bam file : " + filename);
     sam_hdr_t *hdr = sam_hdr_read(hts);
     if (hdr == nullptr)
-      throw runtime_error("cannot read header from bam file : " + filename);
+      throw std::runtime_error("cannot read header from bam file : " +
+                               filename);
     bam1_t *b = bam_init1();
     if (sam_read1(hts, hdr, b) < -1) {
       hts_close(hts);
       sam_hdr_destroy(hdr);
       bam_destroy1(b);
 
-      throw runtime_error("cannot read entry from bam file : " + filename);
+      throw std::runtime_error("cannot read entry from bam file : " + filename);
     }
     else {
       std::string first_entry_name(bam_get_qname(b));
@@ -83,7 +78,7 @@ get_tile_split_position(FalcoConfig &config) {
   }
 #endif
   else if (config.is_fastq_gz) {
-    gzFile in = gzopen(filename.c_str(), "rb");
+    gzFile in = gzopen(std::data(filename), "rb");
     if (!in)
       throw std::runtime_error("problem reading input file: " + filename);
 
@@ -91,10 +86,11 @@ get_tile_split_position(FalcoConfig &config) {
     char buffer[1024];
     gzgets(in, buffer, sizeof(buffer));
     gzclose(in);
-    for (char* itr = buffer; *itr != '\0'; ++itr) {
+    for (char *itr = buffer; *itr != '\0'; ++itr) {
       num_colon += (*itr == ':');
     }
-  } else {
+  }
+  else {
     std::ifstream in(filename);
     if (!in.good())
       throw std::runtime_error("problem reading input file: " + filename);
@@ -110,49 +106,45 @@ get_tile_split_position(FalcoConfig &config) {
   }
 
   // Copied from fastqc
-  if (num_colon >= 6) return 4;
-  else if (num_colon >= 4) return 2;
-  return 0; // no tile information on read name
+  if (num_colon >= 6)
+    return 4;
+  else if (num_colon >= 4)
+    return 2;
+  return 0;  // no tile information on read name
 }
 
 // function to turn a vector into array for adapter hashes and fast lookup
-array<size_t, Constants::max_adapters>
-make_adapters(const vector<size_t> &adapter_hashes) {
+std::array<size_t, Constants::max_adapters>
+make_adapters(const std::vector<size_t> &adapter_hashes) {
   if (adapter_hashes.size() > Constants::max_adapters)
-    throw runtime_error("Number of adapters is larger than 128, which hinders "
-                        "visualziation and speed of falco. Please keep it to "
-                        "under 128");
+    throw std::runtime_error(
+      "Number of adapters is larger than 128, which hinders "
+      "visualziation and speed of falco. Please keep it to "
+      "under 128");
 
-  array<size_t, Constants::max_adapters> ans;
+  std::array<size_t, Constants::max_adapters> ans;
   for (size_t i = 0; i < adapter_hashes.size(); ++i)
     ans[i] = adapter_hashes[i];
 
   return ans;
 }
 
-StreamReader::StreamReader(FalcoConfig &config,
-                           const size_t _buffer_size,
+StreamReader::StreamReader(FalcoConfig &config, const size_t _buffer_size,
                            const char _field_separator,
                            const char _line_separator) :
   // I have to pass the config skips as const to read them fast
   do_sequence_hash(config.do_duplication || config.do_overrepresented),
-  do_kmer(config.do_kmer),
-  do_adapter(config.do_adapter),
+  do_kmer(config.do_kmer), do_adapter(config.do_adapter),
   do_adapter_optimized(config.do_adapter_optimized),
   do_sliding_window(do_adapter_optimized || do_kmer),
-  do_n_content(config.do_n_content),
-  do_quality_base(config.do_quality_base),
-  do_sequence(config.do_sequence),
-  do_gc_sequence(config.do_gc_sequence),
-  do_quality_sequence(config.do_quality_sequence),
-  do_tile(config.do_tile),
+  do_n_content(config.do_n_content), do_quality_base(config.do_quality_base),
+  do_sequence(config.do_sequence), do_gc_sequence(config.do_gc_sequence),
+  do_quality_sequence(config.do_quality_sequence), do_tile(config.do_tile),
   do_sequence_length(config.do_sequence_length),
 
   // Here are the usual stream reader configs
-  field_separator(_field_separator),
-  line_separator(_line_separator),
-  buffer_size(_buffer_size),
-  read_step(config.read_step),
+  field_separator(_field_separator), line_separator(_line_separator),
+  buffer_size(_buffer_size), read_step(config.read_step),
   tile_split_point(get_tile_split_position(config)),
   tile_ignore(!do_tile || tile_split_point == 0),
 
@@ -160,17 +152,15 @@ StreamReader::StreamReader(FalcoConfig &config,
   do_adapters_slow(config.do_adapter && !config.do_adapter_optimized),
   adapter_seqs(config.adapter_seqs),
 
-  num_adapters(config.adapter_hashes.size()),
-  adapter_size(config.adapter_size),
-  //for case size == 32 expr (1ull << 64) -1 gives 0.
-  //We need to set mask as all 64 bits 1 => use SIZE_MAX in this case
-  adapter_mask(adapter_size == 32? SIZE_MAX: (1ull << (2*adapter_size)) - 1),
-  adapters(make_adapters(config.adapter_hashes)),
-  filename(config.filename)
-  {
+  num_adapters(config.adapter_hashes.size()), adapter_size(config.adapter_size),
+  // for case size == 32 expr (1ull << 64) -1 gives 0.
+  // We need to set mask as all 64 bits 1 => use SIZE_MAX in this case
+  adapter_mask(adapter_size == 32 ? SIZE_MAX
+                                  : (1ull << (2 * adapter_size)) - 1),
+  adapters(make_adapters(config.adapter_hashes)), filename(config.filename) {
 
   // Allocates buffer to temporarily store reads
-  buffer = new char[buffer_size + 1]; // +1 for the \0
+  buffer = new char[buffer_size + 1];  // +1 for the \0
   buffer[buffer_size] = '\0';
 
   // duplication init
@@ -185,15 +175,12 @@ StreamReader::StreamReader(FalcoConfig &config,
   next_kmer_read = 0;
   do_tile_read = true;
 
-
   // GS: test
   leftover_ind = 0;
 }
 
 // Makes sure that any subclass deletes the buffer
-StreamReader::~StreamReader() {
-  delete[] buffer;
-}
+StreamReader::~StreamReader() { delete[] buffer; }
 
 /*******************************************************/
 /*************** BUFFER MANAGEMENT *********************/
@@ -213,12 +200,11 @@ StreamReader::put_base_in_buffer() {
   }
 }
 
-
 // Gets base from either buffer or leftover
 void
 StreamReader::get_base_from_buffer() {
-  base_from_buffer = still_in_buffer ?
-                     buffer[read_pos] : leftover_buffer[leftover_ind];
+  base_from_buffer =
+    still_in_buffer ? buffer[read_pos] : leftover_buffer[leftover_ind];
 }
 
 /*******************************************************/
@@ -228,20 +214,23 @@ StreamReader::get_base_from_buffer() {
 // Keeps going forward while the current character is a separator
 inline void
 StreamReader::skip_separator() {
-  for (; *cur_char == field_separator; ++cur_char) {}
+  for (; *cur_char == field_separator; ++cur_char) {
+  }
 }
 
 // Skips lines that are not relevant
 inline void
 StreamReader::read_fast_forward_line() {
-  for (; *cur_char != field_separator; ++cur_char) {}
+  for (; *cur_char != field_separator; ++cur_char) {
+  }
 }
 
 inline void
 StreamReader::read_fast_forward_line_eof() {
-  for (; (*cur_char != field_separator) &&
-         (*cur_char != line_separator) &&
-         !is_eof(); ++cur_char) {}
+  for (; (*cur_char != field_separator) && (*cur_char != line_separator) &&
+         !is_eof();
+       ++cur_char) {
+  }
 }
 
 /*******************************************************/
@@ -249,7 +238,6 @@ StreamReader::read_fast_forward_line_eof() {
 /*******************************************************/
 // Parse the comment
 
-
 void
 StreamReader::get_tile_value() {
   tile_cur = 0;
@@ -257,14 +245,15 @@ StreamReader::get_tile_value() {
   for (; *cur_char != field_separator; ++cur_char) {
     num_colon += (*cur_char == ':');
     if (num_colon == tile_split_point) {
-      ++cur_char; // skip colon
+      ++cur_char;  // skip colon
 
       // parse till next colon or \n
       for (; (*cur_char != ':') && (*cur_char != field_separator); ++cur_char)
-        tile_cur = tile_cur*10 + (*cur_char - '0');
+        tile_cur = tile_cur * 10 + (*cur_char - '0');
 
       // now fast forward until last \n
-      for(; *cur_char != field_separator; ++cur_char);
+      for (; *cur_char != field_separator; ++cur_char)
+        ;
       return;
     }
   }
@@ -297,14 +286,13 @@ StreamReader::read_tile_line(FastqStats &stats) {
   if (stats.tile_position_quality.find(tile_cur) ==
       end(stats.tile_position_quality)) {
     stats.tile_position_quality[tile_cur] =
-      vector<double> (stats.max_read_length , 0.0);
-    //stats.tile_position_quality.find(tile_cur)->second[0] = 0;
+      std::vector<double>(stats.max_read_length, 0.0);
+    // stats.tile_position_quality.find(tile_cur)->second[0] = 0;
     stats.tile_position_count[tile_cur] =
-      vector<size_t> (stats.max_read_length, 0);
+      std::vector<size_t>(stats.max_read_length, 0);
   }
 }
 
-
 /*******************************************************/
 /*************** SEQUENCE PROCESSING *******************/
 /*******************************************************/
@@ -323,9 +311,8 @@ StreamReader::process_sequence_base_from_buffer(FastqStats &stats) {
   else {
     // increments basic statistic counts
     cur_gc_count += (actg_to_2bit(base_from_buffer) & 1);
-    ++stats.base_count[
-      (read_pos << Constants::bit_shift_base) |
-      actg_to_2bit(base_from_buffer)];
+    ++stats.base_count[(read_pos << Constants::bit_shift_base) |
+                       actg_to_2bit(base_from_buffer)];
 
     if (do_sliding_window) {
       // Update k-mer sequence
@@ -333,11 +320,12 @@ StreamReader::process_sequence_base_from_buffer(FastqStats &stats) {
                   actg_to_2bit(base_from_buffer));
 
       // registers k-mer if seen at least k nucleotides since the last n
-      if (do_kmer && do_kmer_read && (num_bases_after_n >= Constants::kmer_size)) {
+      if (do_kmer && do_kmer_read &&
+          (num_bases_after_n >= Constants::kmer_size)) {
 
-          ++stats.kmer_count[(read_pos << Constants::bit_shift_kmer)
-                           | (cur_kmer & Constants::kmer_mask)];
-          ++stats.pos_kmer_count[read_pos];
+        ++stats.kmer_count[(read_pos << Constants::bit_shift_kmer) |
+                           (cur_kmer & Constants::kmer_mask)];
+        ++stats.pos_kmer_count[read_pos];
       }
 
       // GS: slow, need to use fsm
@@ -345,8 +333,9 @@ StreamReader::process_sequence_base_from_buffer(FastqStats &stats) {
         cur_kmer &= adapter_mask;
         for (size_t i = 0; i != num_adapters; ++i) {
           if (cur_kmer == adapters[i] && !adapters_found[i]) {
-            ++stats.pos_adapter_count[
-              (read_pos << Constants::bit_shift_adapter) | i];
+            ++stats
+                .pos_adapter_count[(read_pos << Constants::bit_shift_adapter) |
+                                   i];
             adapters_found[i] = true;
           }
         }
@@ -370,8 +359,8 @@ StreamReader::process_sequence_base_from_leftover(FastqStats &stats) {
   else {
     // increments basic statistic counts
     cur_gc_count += (actg_to_2bit(base_from_buffer) & 1);
-    ++stats.long_base_count[(leftover_ind << Constants::bit_shift_base)
-                          | actg_to_2bit(base_from_buffer)];
+    ++stats.long_base_count[(leftover_ind << Constants::bit_shift_base) |
+                            actg_to_2bit(base_from_buffer)];
 
     // WE WILL NOT DO KMER STATS OUTSIDE OF BUFFER
   }
@@ -396,8 +385,7 @@ StreamReader::postprocess_sequence_line(FastqStats &stats) {
 
   // Updates maximum read length if applicable
   stats.max_read_length =
-    ((read_pos > stats.max_read_length) ?
-     (read_pos) : (stats.max_read_length));
+    ((read_pos > stats.max_read_length) ? (read_pos) : (stats.max_read_length));
 
   // FastQC's gc model summarized, if requested
   if (do_gc_sequence && read_pos != 0) {
@@ -410,11 +398,11 @@ StreamReader::postprocess_sequence_line(FastqStats &stats) {
         truncated_gc_count = cur_gc_count;
       }
       for (const auto &v :
-          stats.gc_models[truncated_length].models[truncated_gc_count]) {
+           stats.gc_models[truncated_length].models[truncated_gc_count]) {
         stats.gc_count[v.percent] += v.increment;
       }
 
-    // if the read length is too large, we just use the discrete percentage
+      // if the read length is too large, we just use the discrete percentage
     }
     else {
       ++stats.gc_count[100 * cur_gc_count / read_pos];
@@ -440,12 +428,13 @@ StreamReader::read_sequence_line(FastqStats &stats) {
   adapters_found.reset();
 
   if (do_adapters_slow) {
-    const string seq_line_str = cur_char;
+    const std::string seq_line_str = cur_char;
     for (size_t i = 0; i != num_adapters; ++i) {
       const size_t adapt_index = seq_line_str.find(adapter_seqs[i], 0);
       if (adapt_index < stats.SHORT_READ_THRESHOLD) {
         ++stats.pos_adapter_count[((adapt_index + adapter_seqs[i].length() - 1)
-            << Constants::bit_shift_adapter) | i];
+                                   << Constants::bit_shift_adapter) |
+                                  i];
       }
     }
   }
@@ -496,8 +485,6 @@ StreamReader::read_sequence_line(FastqStats &stats) {
   postprocess_sequence_line(stats);
 }
 
-
-
 /*******************************************************/
 /*************** QUALITY PROCESSING ********************/
 /*******************************************************/
@@ -505,9 +492,8 @@ StreamReader::read_sequence_line(FastqStats &stats) {
 void
 StreamReader::process_quality_base_from_buffer(FastqStats &stats) {
   // Average quality in position
-  ++stats.position_quality_count[
-    (read_pos << Constants::bit_shift_quality) | quality_value
-  ];
+  ++stats.position_quality_count[(read_pos << Constants::bit_shift_quality) |
+                                 quality_value];
 
   // Tile processing
   if (!tile_ignore && do_tile_read && tile_cur != 0) {
@@ -516,8 +502,7 @@ StreamReader::process_quality_base_from_buffer(FastqStats &stats) {
       stats.tile_position_quality[tile_cur].push_back(0.0);
       stats.tile_position_count[tile_cur].push_back(0);
     }
-    stats.tile_position_quality[tile_cur][read_pos]
-        += quality_value;
+    stats.tile_position_quality[tile_cur][read_pos] += quality_value;
     ++stats.tile_position_count[tile_cur][read_pos];
   }
 }
@@ -526,14 +511,14 @@ StreamReader::process_quality_base_from_buffer(FastqStats &stats) {
 void
 StreamReader::process_quality_base_from_leftover(FastqStats &stats) {
   // Average quality in position
-  ++stats.long_position_quality_count[
-    (leftover_ind << Constants::bit_shift_quality) | quality_value];
+  ++stats.long_position_quality_count[(leftover_ind
+                                       << Constants::bit_shift_quality) |
+                                      quality_value];
 
   // Tile processing
   if (!tile_ignore) {
     if (do_tile_read && tile_cur != 0) {
-      stats.tile_position_quality[tile_cur][read_pos]
-        += quality_value;
+      stats.tile_position_quality[tile_cur][read_pos] += quality_value;
       ++stats.tile_position_count[tile_cur][read_pos];
     }
   }
@@ -545,10 +530,8 @@ StreamReader::read_quality_line(FastqStats &stats) {
   // MN: Below, the second condition tests whether the quality score in sam
   // file only consists of '*', which indicates that no quality score is
   // available
-  if (!do_read ||
-      (*cur_char == '*' &&
-       (*(cur_char + 1) == field_separator ||
-        *(cur_char + 1) == field_separator) ) ) {
+  if (!do_read || (*cur_char == '*' && (*(cur_char + 1) == field_separator ||
+                                        *(cur_char + 1) == field_separator))) {
     read_fast_forward_line_eof();
     return;
   }
@@ -560,9 +543,9 @@ StreamReader::read_quality_line(FastqStats &stats) {
   // For quality, we do not look for the separator, but rather for an explicit
   // newline or EOF in case the file does not end with newline or we are getting
   // decompressed strings from a stream
-  for (; (*cur_char != field_separator) &&
-         (*cur_char != line_separator) &&
-         !is_eof(); ++cur_char) {
+  for (; (*cur_char != field_separator) && (*cur_char != line_separator) &&
+         !is_eof();
+       ++cur_char) {
 
     if (read_pos == buffer_size) {
       still_in_buffer = false;
@@ -572,8 +555,9 @@ StreamReader::read_quality_line(FastqStats &stats) {
     get_base_from_buffer();
 
     // update lowest quality
-    stats.lowest_char = min8(stats.lowest_char,
-        ((*cur_char == 9) ? (std::numeric_limits<char>::max()) : (*cur_char)));
+    stats.lowest_char = min8(
+      stats.lowest_char,
+      ((*cur_char == 9) ? (std::numeric_limits<char>::max()) : (*cur_char)));
 
     // Converts quality ascii to zero-based
     quality_value = *cur_char - Constants::quality_zero;
@@ -602,8 +586,6 @@ StreamReader::read_quality_line(FastqStats &stats) {
     ++stats.quality_count[cur_quality / read_pos];  // avg quality histogram
 }
 
-
-
 /*******************************************************/
 /*************** POST LINE PROCESSING ******************/
 /*******************************************************/
@@ -611,15 +593,16 @@ StreamReader::read_quality_line(FastqStats &stats) {
 // if reads are >75pb, truncate to 50 akin to FastQC
 inline size_t
 get_truncate_point(const size_t read_pos) {
-  return (read_pos <= Constants::unique_reads_max_length) ?
-    read_pos : Constants::unique_reads_truncate;
+  return (read_pos <= Constants::unique_reads_max_length)
+           ? read_pos
+           : Constants::unique_reads_truncate;
 }
 
 void
 StreamReader::postprocess_fastq_record(FastqStats &stats) {
   if (do_sequence_hash) {
     buffer[get_truncate_point(read_pos)] = '\0';
-    sequence_to_hash = string(buffer);
+    sequence_to_hash = std::string(buffer);
     // New sequence found
     if (stats.sequence_count.count(sequence_to_hash) == 0) {
       if (continue_storing_sequences) {
@@ -643,22 +626,22 @@ StreamReader::postprocess_fastq_record(FastqStats &stats) {
       next_tile_read += num_reads_for_tile;
     }
   }
-  next_kmer_read += do_kmer_read*num_reads_for_kmer;
+  next_kmer_read += do_kmer_read * num_reads_for_kmer;
 }
 
 inline bool
 StreamReader::check_bytes_read(const size_t read_num) {
-  return ((read_num&check_bytes_read_mask) == 0);
+  return ((read_num & check_bytes_read_mask) == 0);
 }
 
 /*******************************************************/
 /*************** READ FASTQ RECORD *********************/
 /*******************************************************/
 char
-get_line_separator(const string &filename) {
+get_line_separator(const std::string &filename) {
   FILE *fp = fopen(filename.c_str(), "r");
   if (fp == NULL)
-    throw runtime_error("bad input file: " + filename);
+    throw std::runtime_error("bad input file: " + filename);
 
   while (!feof(fp)) {
     const char c = fgetc(fp);
@@ -672,18 +655,17 @@ get_line_separator(const string &filename) {
 }
 
 // Set fastq field_separator as line_separator
-FastqReader::FastqReader(FalcoConfig &_config,
-                         const size_t _buffer_size) :
-  StreamReader(_config, _buffer_size,
-               get_line_separator(_config.filename), get_line_separator(_config.filename)) {
+FastqReader::FastqReader(FalcoConfig &_config, const size_t _buffer_size) :
+  StreamReader(_config, _buffer_size, get_line_separator(_config.filename),
+               get_line_separator(_config.filename)) {
   filebuf = new char[RESERVE_SIZE];
 }
 
 size_t
-get_file_size(const string &filename) {
-  FILE* fp = fopen(filename.c_str(), "r");
+get_file_size(const std::string &filename) {
+  FILE *fp = fopen(filename.c_str(), "r");
   if (fp == NULL)
-    throw runtime_error("bad input file: " + filename);
+    throw std::runtime_error("bad input file: " + filename);
 
   fseek(fp, 0L, SEEK_END);
   const size_t ret = static_cast<size_t>(ftell(fp));
@@ -697,7 +679,7 @@ size_t
 FastqReader::load() {
   fileobj = fopen(filename.c_str(), "r");
   if (fileobj == NULL)
-    throw runtime_error("Cannot open FASTQ file : " + filename);
+    throw std::runtime_error("Cannot open FASTQ file : " + filename);
   return get_file_size(filename);
 }
 
@@ -723,7 +705,6 @@ FastqReader::read_entry(FastqStats &stats, size_t &num_bytes_read) {
 
   do_read = (stats.num_reads == next_read);
 
-
   read_tile_line(stats);
   skip_separator();
 
@@ -742,7 +723,7 @@ FastqReader::read_entry(FastqStats &stats, size_t &num_bytes_read) {
   if (do_read)
     postprocess_fastq_record(stats);
 
-  next_read += do_read*read_step;
+  next_read += do_read * read_step;
 
   // Successful read, increment number in stats
   ++stats.num_reads;
@@ -757,8 +738,7 @@ FastqReader::read_entry(FastqStats &stats, size_t &num_bytes_read) {
 /*************** READ FASTQ GZ RCORD *******************/
 /*******************************************************/
 // the gz fastq constructor is the same as the fastq
-GzFastqReader::GzFastqReader(FalcoConfig &_config,
-                             const size_t _buffer_size) :
+GzFastqReader::GzFastqReader(FalcoConfig &_config, const size_t _buffer_size) :
   StreamReader(_config, _buffer_size, '\n', '\n') {
   gzbuf = new char[RESERVE_SIZE];
 }
@@ -768,7 +748,7 @@ size_t
 GzFastqReader::load() {
   fileobj = gzopen(filename.c_str(), "r");
   if (fileobj == Z_NULL)
-    throw runtime_error("Cannot open gzip FASTQ file : " + filename);
+    throw std::runtime_error("Cannot open gzip FASTQ file : " + filename);
 
   return get_file_size(filename);
 }
@@ -813,7 +793,7 @@ GzFastqReader::read_entry(FastqStats &stats, size_t &num_bytes_read) {
   if (do_read)
     postprocess_fastq_record(stats);
 
-  next_read += do_read*read_step;
+  next_read += do_read * read_step;
 
   // Successful read, increment number in stats
   ++stats.num_reads;
@@ -828,10 +808,9 @@ GzFastqReader::read_entry(FastqStats &stats, size_t &num_bytes_read) {
 /*************** READ SAM RECORD ***********************/
 /*******************************************************/
 // set sam separator as tab
-SamReader::SamReader(FalcoConfig &_config,
-                     const size_t _buffer_size) :
-  StreamReader(_config, _buffer_size,
-               '\t', get_line_separator(_config.filename)) {
+SamReader::SamReader(FalcoConfig &_config, const size_t _buffer_size) :
+  StreamReader(_config, _buffer_size, '\t',
+               get_line_separator(_config.filename)) {
   filebuf = new char[RESERVE_SIZE];
 }
 
@@ -839,7 +818,7 @@ size_t
 SamReader::load() {
   fileobj = fopen(filename.c_str(), "r");
   if (fileobj == NULL)
-    throw runtime_error("Cannot open SAM file : " + filename);
+    throw std::runtime_error("Cannot open SAM file : " + filename);
 
   // skip sam header
   char first_char_in_line;
@@ -859,7 +838,8 @@ bool
 SamReader::read_entry(FastqStats &stats, size_t &num_bytes_read) {
   cur_char = fgets(filebuf, RESERVE_SIZE, fileobj);
 
-  if (is_eof()) return false;
+  if (is_eof())
+    return false;
   do_read = (stats.num_reads == next_read);
 
   read_tile_line(stats);
@@ -879,14 +859,14 @@ SamReader::read_entry(FastqStats &stats, size_t &num_bytes_read) {
   if (do_read)
     postprocess_fastq_record(stats);
 
-  next_read += do_read*read_step;
+  next_read += do_read * read_step;
   ++stats.num_reads;
 
   // skips all tags after quality until newline
   for (; *cur_char != line_separator && !is_eof(); ++cur_char)
 
-  if (check_bytes_read(stats.num_reads))
-    num_bytes_read = ftell(fileobj);
+    if (check_bytes_read(stats.num_reads))
+      num_bytes_read = ftell(fileobj);
 
   // Returns if file should keep being checked
   return (!is_eof() && cur_char != 0);
@@ -917,7 +897,8 @@ BamReader::put_base_in_buffer(const size_t pos) {
 // Specially made to work directly with bam1_t
 void
 BamReader::read_sequence_line(FastqStats &stats) {
-  if (!do_read) return;
+  if (!do_read)
+    return;
 
   // restart line counters
   read_pos = 0;
@@ -932,7 +913,7 @@ BamReader::read_sequence_line(FastqStats &stats) {
   const size_t seq_len = b->core.l_qseq;
   // MN: TODO: make sure everything works in this scope
   if (do_adapters_slow) {
-    string seq_line_str(seq_len, '\0');
+    std::string seq_line_str(seq_len, '\0');
     for (size_t i = 0; i < seq_len; i++) {
       seq_line_str[i] = seq_nt16_str[bam_seqi(cur_char, i)];
     }
@@ -940,7 +921,8 @@ BamReader::read_sequence_line(FastqStats &stats) {
       const size_t adapt_index = seq_line_str.find(adapter_seqs[i], 0);
       if (adapt_index < stats.SHORT_READ_THRESHOLD) {
         ++stats.pos_adapter_count[((adapt_index + adapter_seqs[i].length() - 1)
-            << Constants::bit_shift_adapter) | i];
+                                   << Constants::bit_shift_adapter) |
+                                  i];
       }
     }
   }
@@ -992,8 +974,6 @@ BamReader::read_sequence_line(FastqStats &stats) {
 
   // statistics summarized after the read
   postprocess_sequence_line(stats);
-
-
 }
 
 void
@@ -1019,8 +999,8 @@ BamReader::read_quality_line(FastqStats &stats) {
     get_base_from_buffer();
 
     // MN: Adding quality_zero to emulate the behavior of the original function.
-    stats.lowest_char = min8(stats.lowest_char,
-        static_cast<char>(*cur_char + 33));
+    stats.lowest_char =
+      min8(stats.lowest_char, static_cast<char>(*cur_char + 33));
 
     // Converts quality ascii to zero-based
     quality_value = *cur_char;
@@ -1049,7 +1029,6 @@ BamReader::read_quality_line(FastqStats &stats) {
     ++stats.quality_count[cur_quality / read_pos];  // avg quality histogram
 }
 
-
 /*******************************************************/
 /*************** READ BAM RECORD ***********************/
 /*******************************************************/
@@ -1065,7 +1044,7 @@ BamReader::read_quality_line(FastqStats &stats) {
  * take care when handling odd-length sequences.
  */
 static const uint8_t byte_revcom_table[] = {
-// clang-format off
+  // clang-format off
     0,   0,   0,   0,   0,   0,   0,   0,
     0,   0,   0,   0,   0,   0,   0,   0,
     8, 136,  72,   0,  40,   0,   0,   0,
@@ -1111,7 +1090,8 @@ revcom_byte_then_reverse(unsigned char *a, unsigned char *b) {
     *p2 ^= *p1;
     *p1 ^= *p2;
   }
-  if (p1 == p2) *p1 = byte_revcom_table[*p1];
+  if (p1 == p2)
+    *p1 = byte_revcom_table[*p1];
 }
 
 static inline void
@@ -1145,13 +1125,13 @@ BamReader::BamReader(FalcoConfig &_config, const size_t _buffer_size) :
 size_t
 BamReader::load() {
   if (!(hts = hts_open(filename.c_str(), "r")))
-    throw runtime_error("cannot load bam file : " + filename);
+    throw std::runtime_error("cannot load bam file : " + filename);
 
   if (!(hdr = sam_hdr_read(hts)))
-    throw runtime_error("failed to read header from file: " + filename);
+    throw std::runtime_error("failed to read header from file: " + filename);
 
   if (!(b = bam_init1()))
-    throw runtime_error("failed to read record from file: " + filename);
+    throw std::runtime_error("failed to read record from file: " + filename);
 
   // GS TODO: implement this properly
   return 1;
@@ -1188,11 +1168,11 @@ BamReader::read_entry(FastqStats &stats, size_t &num_bytes_read) {
 
     // Read sequence line
     size_t seq_len = b->core.l_qseq;
-    cur_char = reinterpret_cast<char*>(bam_get_seq(b));
+    cur_char = reinterpret_cast<char *>(bam_get_seq(b));
     BamReader::read_sequence_line(stats);
 
     // Read quality line
-    cur_char = reinterpret_cast<char*>(bam_get_qual(b));
+    cur_char = reinterpret_cast<char *>(bam_get_qual(b));
     // Set the first byte after qual to line_separator
     // So that read_quality_line stops at the end of qual
     cur_char[seq_len] = line_separator;
@@ -1202,56 +1182,14 @@ BamReader::read_entry(FastqStats &stats, size_t &num_bytes_read) {
     if (do_read)
       postprocess_fastq_record(stats);
 
-    next_read += do_read*read_step;
+    next_read += do_read * read_step;
     ++stats.num_reads;
     return true;
-
   }
   // If I could not read another line it means it's eof
   return false;
 }
 
-//bool
-//BamReader::read_entry(FastqStats &stats, size_t &num_bytes_read) {
-  //if ((rd_ret = sam_read1(hts, hdr, b)) >= 0) {
-    //fmt_ret = 0;
-
-    //// GS TODO: implement this properly
-    //num_bytes_read = 0;
-    //if ((fmt_ret = sam_format1(hdr, b, &hts->line)) > 0) {
-      //// define char* values for processing lines char by char
-      //cur_char = hts->line.s;
-      //last = cur_char + strlen(hts->line.s) - 1;
-
-      //do_read = (stats.num_reads == next_read);
-
-      //// Now read it as regular sam
-      //read_tile_line(stats);
-      //skip_separator();
-      //for (size_t i = 0; i < 8; ++i) {
-        //read_fast_forward_line();
-        //skip_separator();
-      //}
-
-      //StreamReader::read_sequence_line(stats);
-      //skip_separator();
-      //read_quality_line(stats);
-
-      //if (do_read)
-        //postprocess_fastq_record(stats);
-
-      //next_read += do_read*read_step;
-      //++stats.num_reads;
-      //return true;
-    //}
-    //else throw runtime_error("failed reading record from: " + filename);
-
-    //return false;
-  //}
-  //// If I could not read another line it means it's eof
-  //return false;
-//}
-
 BamReader::~BamReader() {
   if (hdr) {
     bam_hdr_destroy(hdr);
diff --git a/src/falco.cpp b/src/falco.cpp
index 53e789c..2f21148 100644
--- a/src/falco.cpp
+++ b/src/falco.cpp
@@ -18,6 +18,8 @@
 #include <chrono>
 #include <filesystem>
 #include <fstream>
+#include <string>
+#include <vector>
 
 #include "FalcoConfig.hpp"
 #include "FastqStats.hpp"
@@ -27,22 +29,21 @@
 #include "StreamReader.hpp"
 #include "smithlab_utils.hpp"
 
-using std::chrono::duration_cast;
-using std::chrono::system_clock;
-using time_point = std::chrono::time_point<std::chrono::system_clock>;
-
 // Function to get seconds elapsed in program
-static size_t
-get_seconds_since(const time_point &start_time) {
-  const auto current_time = system_clock::now();
+static std::size_t
+get_seconds_since(
+  const std::chrono::time_point<std::chrono::system_clock> &start_time) {
+  const auto current_time = std::chrono::system_clock::now();
   const auto time_difference = current_time - start_time;
-  return duration_cast<std::chrono::seconds>(time_difference).count();
+  return std::chrono::duration_cast<std::chrono::seconds>(time_difference)
+    .count();
 }
 
 // Function to print progress nicely
 static inline void
 log_process(const std::string &s) {
-  auto tmp = system_clock::to_time_t(system_clock::now());
+  auto tmp =
+    std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
   std::string time_fmt(std::ctime(&tmp));
   time_fmt.pop_back();
   std::cerr << "[" << time_fmt << "] " << s << '\n';
@@ -60,8 +61,8 @@ template <typename T>
 void
 read_stream_into_stats(T &in, FastqStats &stats, FalcoConfig &falco_config) {
   // open file
-  size_t file_size = std::max(in.load(), static_cast<size_t>(1));
-  size_t tot_bytes_read = 0;
+  std::size_t file_size = std::max(in.load(), static_cast<std::size_t>(1));
+  std::size_t tot_bytes_read = 0;
 
   // Read record by record
   const bool report_progress = falco_config.progress;
@@ -149,8 +150,8 @@ write_results(const FalcoConfig &falco_config, FastqStats &stats,
   std::ofstream qc_data_txt;
   if (!skip_text) {
     const std::string qc_data_file =
-      (data_filename.empty() ? (outdir + "/" + file_prefix + "fastqc_data.txt")
-                             : (data_filename));
+      data_filename.empty() ? outdir + "/" + file_prefix + "fastqc_data.txt"
+                            : data_filename;
     qc_data_txt.open(qc_data_file, std::ofstream::binary);
 
     if (!qc_data_txt.good())
@@ -562,16 +563,16 @@ main(int argc, char *argv[]) {
       return EXIT_SUCCESS;
     }
 
-    if (leftover_args.size() == 0) {
+    if (std::size(leftover_args) == 0) {
       std::cerr << opt_parse.help_message() << '\n';
       return EXIT_SUCCESS;
     }
 
-    if (leftover_args.size() > 1 &&
+    if (std::size(leftover_args) > 1 &&
         (!summary_filename.empty() || !report_filename.empty() ||
          !data_filename.empty())) {
       std::cerr << "ERROR: summary, report or data filename provided, but"
-                << " you are running falco with " << leftover_args.size()
+                << " you are running falco with " << std::size(leftover_args)
                 << " inputs. We cannot allow this because multiple inputs"
                 << " require multiple outputs, so they will be resolved by"
                 << " the input filenames instead\n";
@@ -620,7 +621,7 @@ main(int argc, char *argv[]) {
           log_process("creating directory for output: " + outdir);
 
         // makes directory with r and w permission
-        if (mkdir(outdir.c_str(), S_IRUSR | S_IWUSR | S_IXUSR) != 0) {
+        if (mkdir(std::data(outdir), S_IRUSR | S_IWUSR | S_IXUSR) != 0) {
           std::cerr << "failed to create directory: " << outdir
                     << ". Make sure you have write permissions on it!\n";
           return EXIT_FAILURE;
@@ -631,7 +632,7 @@ main(int argc, char *argv[]) {
 
     // check if all filenames exist
     bool all_files_exist = true;
-    for (size_t i = 0; i < all_seq_filenames.size(); ++i) {
+    for (std::size_t i = 0; i < std::size(all_seq_filenames); ++i) {
       if (!file_exists(all_seq_filenames[i])) {
         std::cerr << "ERROR! File does not exist: " << all_seq_filenames[i]
                   << '\n';
@@ -648,7 +649,7 @@ main(int argc, char *argv[]) {
     /****************** END COMMAND LINE OPTIONS ********************/
     for (const auto &filename : all_seq_filenames) {
 
-      const time_point file_start_time = system_clock::now();
+      const auto file_start_time = std::chrono::system_clock::now();
 
       falco_config.filename = filename;
 
@@ -710,7 +711,7 @@ main(int argc, char *argv[]) {
       // if oudir is empty we will set it as the filename path
       std::string cur_outdir;
 
-      const size_t last_slash_idx = filename.rfind('/');
+      const std::size_t last_slash_idx = filename.rfind('/');
       std::string file_basename =
         falco_config.filename.substr(last_slash_idx + 1);
       if (outdir.empty()) {
@@ -728,8 +729,9 @@ main(int argc, char *argv[]) {
       }
 
       // Write results
-      const std::string file_prefix =
-        (all_seq_filenames.size() == 1) ? ("") : (file_basename + "_");
+      const std::string file_prefix = std::size(all_seq_filenames) == 1
+                                        ? std::string{}
+                                        : (file_basename + "_");
       write_results(falco_config, stats, skip_text, skip_html,
                     skip_short_summary, do_call, file_prefix, cur_outdir,
                     summary_filename, data_filename, report_filename);
diff --git a/src/falcodiff.cpp b/src/falcodiff.cpp
index b687611..9833c5f 100644
--- a/src/falcodiff.cpp
+++ b/src/falcodiff.cpp
@@ -15,53 +15,41 @@
  * General Public License for more details.
  */
 
-#include <fstream>
-#include <chrono>
-#include <sys/stat.h>
-#include "smithlab_utils.hpp"
-#include "OptionParser.hpp"
 #include "FalcoConfig.hpp"
 #include "FastqStats.hpp"
 #include "HtmlMaker.hpp"
 #include "Module.hpp"
+#include "OptionParser.hpp"
+#include "smithlab_utils.hpp"
 
-using std::string;
-using std::runtime_error;
-using std::cerr;
-using std::cout;
-using std::endl;
-using std::vector;
-using std::ostream;
-using std::ofstream;
-using std::to_string;
-using std::chrono::system_clock;
-using std::chrono::duration_cast;
-using std::istream;
-using std::ifstream;
-using time_point = std::chrono::time_point<std::chrono::system_clock>;
+#include <chrono>
+#include <fstream>
+#include <sys/stat.h>
 
 // Function to get seconds elapsed in program
 static size_t
-get_seconds_since(const time_point &start_time) {
-  auto current_time = system_clock::now();
+get_seconds_since(
+  const std::chrono::time_point<std::chrono::system_clock> &start_time) {
+  auto current_time = std::chrono::system_clock::now();
   auto time_difference = current_time - start_time;
-  return duration_cast<std::chrono::seconds>(time_difference).count();
+  return std::chrono::duration_cast<std::chrono::seconds>(time_difference)
+    .count();
 }
 
 // Function to print progress nicely
 static inline void
-log_process(const string &s) {
+log_process(const std::string &s) {
   auto tmp = system_clock::to_time_t(system_clock::now());
-  string time_fmt(std::ctime(&tmp));
+  std::string time_fmt(std::ctime(&tmp));
   time_fmt.pop_back();
-  cerr << "[" << time_fmt << "] " << s << endl;
+  std::cerr << "[" << time_fmt << "] " << s << '\n';
 }
 
 // Function to check existance of directory
 static bool
-dir_exists(const string &path) {
+dir_exists(const std::string &path) {
   struct stat info;
-  if (stat(path.c_str(), &info ) != 0)
+  if (stat(path.c_str(), &info) != 0)
     return false;
   else if (info.st_mode & S_IFDIR)
     return true;
@@ -74,27 +62,27 @@ dir_exists(const string &path) {
 
 // skip lines that are empty or comments
 inline bool
-is_skippable(const string &line) {
+is_skippable(const std::string &line) {
   return (line.empty() || (line[0] == '#'));
 }
 
 inline bool
-is_module_start(const string &line) {
+is_module_start(const std::string &line) {
   return (line.rfind(">>", 0) == 0);
 }
 
 inline bool
-is_module_end(const string &line) {
+is_module_end(const std::string &line) {
   return (line == ">>END_MODULE");
 }
 
-string
-get_module_name(const string &line) {
+std::string
+get_module_name(const std::string &line) {
   if (line.size() < 2 || line[0] != '>' || line[1] != '>')
-    throw runtime_error("Bad module name line: " + line);
+    throw std::runtime_error("Bad module name line: " + line);
 
   // two things: take the >> and the "pass/warn/fail" at the end
-  string ans = line.substr(2);
+  std::string ans = line.substr(2);
   size_t last_tab = ans.find_last_of("\t");
   ans = ans.substr(0, last_tab);
 
@@ -103,26 +91,19 @@ get_module_name(const string &line) {
 
 // prints in tsv the value, a/b and
 void
-print_measure_and_diff(ostream &os,
-                       const string measure,
-                       double v1,
+print_measure_and_diff(std::ostream &os, const std::string measure, double v1,
                        double v2) {
-  os << measure << "\t"
-     << v1 << ":"
-     << v2 << "\t"
-     << abs(v1 - v2) << "\n";
+  os << measure << "\t" << v1 << ":" << v2 << "\t" << abs(v1 - v2) << "\n";
 }
 
-template <typename T> void
-parse_module(T m1, T m2, istream &lhs, istream &rhs) {
-  string line_lhs, line_rhs;
-  while (getline(lhs, line_lhs) &&
-         getline(rhs, line_rhs) &&
-         !is_module_end(line_lhs) &&
-         !is_module_end(line_rhs)) {
+template <typename T>
+void
+parse_module(T m1, T m2, std::istream &lhs, std::istream &rhs) {
+  std::string line_lhs, line_rhs;
+  while (getline(lhs, line_lhs) && getline(rhs, line_rhs) &&
+         !is_module_end(line_lhs) && !is_module_end(line_rhs)) {
 
-    if (!is_skippable(line_lhs) &&
-        !is_skippable(line_rhs)) {
+    if (!is_skippable(line_lhs) && !is_skippable(line_rhs)) {
       m1.read_data_line(line_lhs);
       m2.read_data_line(line_rhs);
     }
@@ -130,30 +111,29 @@ parse_module(T m1, T m2, istream &lhs, istream &rhs) {
 }
 
 void
-compare_fastqcs(istream &lhs, istream &rhs,
-                ostream &os,
+compare_fastqcs(std::istream &lhs, std::istream &rhs, std::ostream &os,
                 const FalcoConfig &config) {
-  string line_lhs, line_rhs, module_name;
+  std::string line_lhs, line_rhs, module_name;
   while (!lhs.eof() && !rhs.eof()) {
     getline(lhs, line_lhs);
     getline(rhs, line_rhs);
 
     if (!is_skippable(line_lhs)) {
       if (is_skippable(line_rhs))
-        throw runtime_error("lines not aligned (rhs skippable, lhs not");
+        throw std::runtime_error("lines not aligned (rhs skippable, lhs not");
 
       if (is_module_start(line_lhs)) {
         if (line_lhs != line_rhs)
-          throw runtime_error("modules not aligned. lhs = " + line_lhs +
-                              "rhs = " + line_rhs);
+          throw std::runtime_error("modules not aligned. lhs = " + line_lhs +
+                                   "rhs = " + line_rhs);
 
-        string module_name = get_module_name(line_lhs);
+        std::string module_name = get_module_name(line_lhs);
         // Basic statistics
         if (module_name == ModuleBasicStatistics::module_name) {
           // define
           ModuleBasicStatistics m1(config), m2(config);
           // read
-          cerr << "parsing basic statistics\n";
+          std::cerr << "parsing basic statistics\n";
           parse_module(m1, m2, lhs, rhs);
 
           // write
@@ -161,30 +141,24 @@ compare_fastqcs(istream &lhs, istream &rhs,
           os << "LHS file:\t" << m1.filename_stripped << "\n";
           os << "RHS file:\t" << m2.filename_stripped << "\n";
           os << "#measure\ta:b\tabs_diff\n";
-          print_measure_and_diff(os, "total_sequences",
-                                      m1.total_sequences,
-                                      m2.total_sequences);
-          print_measure_and_diff(os, "min_read_length",
-                                     m1.min_read_length,
-                                     m2.min_read_length);
-          print_measure_and_diff(os, "max_read_length",
-                                     m1.max_read_length,
-                                     m2.max_read_length);
-          print_measure_and_diff(os,"gc_percent", m1.avg_gc, m2.avg_gc);
+          print_measure_and_diff(os, "total_sequences", m1.total_sequences,
+                                 m2.total_sequences);
+          print_measure_and_diff(os, "min_read_length", m1.min_read_length,
+                                 m2.min_read_length);
+          print_measure_and_diff(os, "max_read_length", m1.max_read_length,
+                                 m2.max_read_length);
+          print_measure_and_diff(os, "gc_percent", m1.avg_gc, m2.avg_gc);
         }
 
         // Per base sequence quality
         if (module_name == ModulePerBaseSequenceQuality::module_name) {
           ModulePerBaseSequenceQuality m1(config), m2(config);
-          cerr << "parsing per base sequence quality\n";
+          std::cerr << "parsing per base sequence quality\n";
           // read
-          while (getline(lhs, line_lhs) &&
-                 getline(rhs, line_rhs) &&
-                 !is_module_end(line_lhs) &&
-                 !is_module_end(line_rhs)) {
+          while (getline(lhs, line_lhs) && getline(rhs, line_rhs) &&
+                 !is_module_end(line_lhs) && !is_module_end(line_rhs)) {
 
-            if (!is_skippable(line_lhs) &&
-                !is_skippable(line_rhs)) {
+            if (!is_skippable(line_lhs) && !is_skippable(line_rhs)) {
               m1.read_data_line(line_lhs);
               m2.read_data_line(line_rhs);
             }
@@ -195,21 +169,22 @@ compare_fastqcs(istream &lhs, istream &rhs,
 
     // check if line in other file is also a comment/skippable
     else if (!is_skippable(line_rhs)) {
-      throw runtime_error("lines not aligned (lhs skippable, rhs not");
+      throw std::runtime_error("lines not aligned (lhs skippable, rhs not");
     }
   }
 
   if (!lhs.eof() || !rhs.eof())
-    throw runtime_error("the two files do not have the same number of lines!");
+    throw std::runtime_error(
+      "the two files do not have the same number of lines!");
 }
 
-int main(int argc, const char **argv) {
+int
+main(int argc, const char **argv) {
   try {
     const time_point file_start_time = system_clock::now();
     bool help = false;
     bool VERBOSE = false;
 
-
     // skip outputs
     bool skip_text = false;
     bool skip_html = false;
@@ -217,80 +192,83 @@ int main(int argc, const char **argv) {
 
     FalcoConfig config;
 
-    string outdir;
-    const string outdir_description =
+    std::string outdir;
+    const std::string outdir_description =
       "Create all output files in the specified output directory. If not"
       "provided, files will be created in the same directory as the input "
       "file.";
 
-    static const string description =
+    static const std::string description =
       "A tool for quality comparison of two samples";
 
     /****************** COMMAND LINE OPTIONS ********************/
-    OptionParser opt_parse(argv[0], description, 
+    OptionParser opt_parse(argv[0], description,
                            "<fastqc_data_1.txt> <fastqc_data_2.txt>");
     opt_parse.add_opt("-help", 'h', "print this help file and exit", false,
-                        help);
+                      help);
     opt_parse.add_opt("-outdir", 'o', outdir_description, false, outdir);
-    opt_parse.add_opt("-skip-text", 'T', "Skip generating text file "
-                      "(Default = false)", false, skip_text);
-    opt_parse.add_opt("-skip-html", 'H', "Skip generating HTML file "
-                      "(Default = false)", false, skip_html);
-    opt_parse.add_opt("-skip-short-summary", 'S', "Skip short summary"
-                      "(Default = false)", false, skip_short_summary);
-    opt_parse.add_opt("-verbose", 'v', "print more run info", false,
-                      VERBOSE);
-
-    vector<string> leftover_args;
+    opt_parse.add_opt("-skip-text", 'T',
+                      "Skip generating text file "
+                      "(Default = false)",
+                      false, skip_text);
+    opt_parse.add_opt("-skip-html", 'H',
+                      "Skip generating HTML file "
+                      "(Default = false)",
+                      false, skip_html);
+    opt_parse.add_opt("-skip-short-summary", 'S',
+                      "Skip short summary"
+                      "(Default = false)",
+                      false, skip_short_summary);
+    opt_parse.add_opt("-verbose", 'v', "print more run info", false, VERBOSE);
+
+    std::vector<std::string> leftover_args;
     opt_parse.parse(argc, argv, leftover_args);
     if (argc == 1 || opt_parse.help_requested()) {
-      cerr << opt_parse.help_message() << endl
-           << opt_parse.about_message() << endl;
+      std::cerr << opt_parse.help_message() << '\n'
+                << opt_parse.about_message() << '\n';
       return EXIT_SUCCESS;
     }
     if (opt_parse.about_requested()) {
-      cerr << opt_parse.about_message() << endl;
+      std::cerr << opt_parse.about_message() << '\n';
       return EXIT_SUCCESS;
     }
     if (opt_parse.option_missing()) {
-      cerr << opt_parse.option_missing_message() << endl;
+      std::cerr << opt_parse.option_missing_message() << '\n';
       return EXIT_SUCCESS;
     }
 
     if (leftover_args.size() != 2) {
-      cerr << "Number of arguments should be two!\n";
-      cerr << opt_parse.help_message() << endl;
+      std::cerr << "Number of arguments should be two!\n";
+      std::cerr << opt_parse.help_message() << '\n';
       return EXIT_SUCCESS;
     }
 
     if (!outdir.empty() && !dir_exists(outdir)) {
-      cerr << "output directory does not exist: " << outdir << endl;
+      std::cerr << "output directory does not exist: " << outdir << '\n';
       return EXIT_FAILURE;
     }
-    const string file1 = leftover_args[0],
-                 file2 = leftover_args[1];
+    const std::string file1 = leftover_args[0];
+    const std::string file2 = leftover_args[1];
 
     // read the two files and check if they exist
-    ifstream lhs(file1), rhs(file2);
+    std::ifstream lhs(file1), rhs(file2);
     if (!lhs)
-      throw runtime_error("File not found: " + file1);
+      throw std::runtime_error("File not found: " + file1);
     if (!rhs)
-      throw runtime_error("File not found: " + file2);
+      throw std::runtime_error("File not found: " + file2);
 
     /****************** END COMMAND LINE OPTIONS ********************/
 
-    compare_fastqcs(lhs, rhs, cout, config);
+    compare_fastqcs(lhs, rhs, std::cout, config);
     if (VERBOSE)
-      cerr << "Elapsed time: "
-           << get_seconds_since(file_start_time) << "s" << endl;
+      std::cerr << "Elapsed time: " << get_seconds_since(file_start_time)
+                << "s\n";
 
     return EXIT_SUCCESS;
   }
-  catch (const runtime_error &e) {
-    cerr << e.what() << endl;
+  catch (const std::runtime_error &e) {
+    std::cerr << e.what() << '\n';
     return EXIT_FAILURE;
   }
   return EXIT_SUCCESS;
 }
-
-