diff --git a/.cppcheck_suppress b/.cppcheck_suppress
index 2145129..fc80470 100644
--- a/.cppcheck_suppress
+++ b/.cppcheck_suppress
@@ -35,9 +35,12 @@ missingInclude
 *:*CLI11.hpp
 *:*json.hpp
 *:*boost_unordered.hpp
+*:fmt/*.h
 # Problem caused by external files
 toomanyconfigs
 # More problems caused by external files -- with too many ifdefs
 normalCheckLevelMaxBranches
 # This seems not to work with the designs used here
 duplInheritedMember
+# Seems like iterator variables for std::views disagree with this
+constStatement
diff --git a/src/adapter_matcher.cpp b/src/adapter_matcher.cpp
index 0ac539a..822e9e5 100644
--- a/src/adapter_matcher.cpp
+++ b/src/adapter_matcher.cpp
@@ -131,6 +131,7 @@ y: {},
 type: "line",
 name: "{}",
 }})";
+  // NOLINTNEXTLINE(clang-analyzer-optin.cplusplus.UninitializedObject)
   assert(std::size(groups) == std::size(adap_counts));
   // calcualte the x axis first
   const auto x = groups | std::views::transform([&](const auto &g) {
@@ -146,9 +147,9 @@ name: "{}",
     std::ranges::transform(cumulative[curr], cumulative[prev],
                            std::begin(cumulative[curr]), std::plus{});
 #endif
-  const auto n_pos = max_read_len + 1 >= adapter_size
-                       ? max_read_len - adapter_size + 1
-                       : max_read_len;
+  // NOLINTNEXTLINE(clang-analyzer-optin.cplusplus.UninitializedObject)
+  const auto n_pos =
+    max_read_len + 1 > adapter_size ? (max_read_len + 1) - adapter_size : 0U;
   const auto last_group_to_keep = std::ranges::find_if(
     groups, [&](const auto &g) { return n_pos <= g.first; });
   cumulative.resize(std::distance(std::cbegin(groups), last_group_to_keep));
@@ -164,13 +165,15 @@ name: "{}",
       return pct_of_reads(cumul[adap_id]);
     };
     const auto y = cumulative | std::views::transform(make_y);
+    // NOLINTNEXTLINE(clang-analyzer-optin.cplusplus.UninitializedObject)
     html_by_adapter.emplace_back(fmt::format(adapter_fmt, x, y, adap_name));
   }
   const auto grade = grades.grade(label);
   const auto title = grades.get_title(label);
-  return fmt::format(
-    html_module_fmt, grade, label, title, grade,
-    std::format(plot_fmt, fmt::format("[{:n:}]", html_by_adapter)));
+  const auto the_plot =
+    // NOLINTNEXTLINE(clang-analyzer-optin.cplusplus.UninitializedObject)
+    std::format(plot_fmt, fmt::format("[{:n:}]", html_by_adapter));
+  return fmt::format(html_module_fmt, grade, label, title, grade, the_plot);
 }
 
 auto
diff --git a/src/adapter_set.cpp b/src/adapter_set.cpp
index bf94c70..20b44a8 100644
--- a/src/adapter_set.cpp
+++ b/src/adapter_set.cpp
@@ -39,7 +39,8 @@ load_adapters(const std::string &filename) {
     // ADS: need to make sure this can't fail
     line.remove_suffix(std::size(line) - to_keep_suffix - 1);
     std::string cleaned_line;
-    for (auto itr = std::cbegin(line); itr != std::cend(line); ++itr)
+    for (auto itr = std::cbegin(line); itr != std::cend(line);
+         itr = std::next(itr))
       if (!std::isblank(*itr) ||
           (std::next(itr) != std::cend(line) && *itr != *std::next(itr)))
         cleaned_line += *itr;
diff --git a/src/bam_file.cpp b/src/bam_file.cpp
index cd152bc..bee2257 100644
--- a/src/bam_file.cpp
+++ b/src/bam_file.cpp
@@ -19,7 +19,9 @@
 #include <stdexcept>
 #include <string>
 #include <system_error>
+#include <tuple>
 #include <utility>
+#include <vector>
 
 [[nodiscard]] auto
 estimate_n_reads_bam(const std::string &filename)
@@ -63,8 +65,8 @@ estimate_n_reads_bam(const std::string &filename)
 }
 
 [[nodiscard]] auto
-init_dups(const std::string &filename,
-          const std::uint64_t n_unique) -> dups_map_t {
+init_dups(const std::string &filename, const std::uint64_t n_unique)
+  -> dups_map_t {
   static constexpr auto complem = [](const auto x) {
     return "TNGNNNCNNNNNNNNNNNNA"[x - 'A'];
   };
diff --git a/src/bam_file.hpp b/src/bam_file.hpp
index 606df5d..93b52e4 100644
--- a/src/bam_file.hpp
+++ b/src/bam_file.hpp
@@ -62,7 +62,10 @@ class bam_file {
   ~bam_file() = default;
   // clang-format on
 
-  [[nodiscard]] operator bool() const { return !had_last_chunks; }
+  [[nodiscard]]
+  operator bool() const {
+    return !had_last_chunks;
+  }
 
   friend auto
   reset(bam_file &reads_file) -> void;
@@ -121,8 +124,8 @@ estimate_n_reads_bam(const std::string &filename)
   -> std::tuple<std::uint64_t, std::uint64_t, std::int64_t>;
 
 [[nodiscard]] auto
-init_dups(const std::string &filename,
-          const std::uint64_t n_unique) -> dups_map_t;
+init_dups(const std::string &filename, const std::uint64_t n_unique)
+  -> dups_map_t;
 
 inline auto
 make_tasks(bam_file &reads_file,          //
diff --git a/src/base_groups.hpp b/src/base_groups.hpp
index 75a561d..2dcbc06 100644
--- a/src/base_groups.hpp
+++ b/src/base_groups.hpp
@@ -23,8 +23,8 @@ make_base_groups(const std::uint64_t n_bases, const std::uint64_t n_initial,
                  const std::uint64_t n_groups_target) -> base_group_vec;
 
 [[nodiscard]] auto
-get_default_base_groups(const std::uint64_t n_bases,
-                        const bool make_groups) -> base_group_vec;
+get_default_base_groups(const std::uint64_t n_bases, const bool make_groups)
+  -> base_group_vec;
 
 [[nodiscard]] auto
 make_group_tag(const base_group_t g) -> std::string;
@@ -32,7 +32,7 @@ make_group_tag(const base_group_t g) -> std::string;
 [[nodiscard]] auto
 make_group_tag_quoted(const base_group_t g) -> std::string;
 
-[[nodiscard]] auto
+void
 apply_base_groups(const base_group_vec &groups, auto &rows) {
   assert(std::size(rows) <= groups.back().second);
   auto group_itr = std::cbegin(groups);
@@ -50,7 +50,7 @@ apply_base_groups(const base_group_vec &groups, auto &rows) {
   rows.resize(current_row);
 }
 
-[[nodiscard]] auto
+void
 apply_base_groups(const base_group_vec &groups, auto &rows, const auto &adder) {
   assert(std::size(rows) <= groups.back().second);
   auto group_itr = std::cbegin(groups);
diff --git a/src/bgzf_reader.cpp b/src/bgzf_reader.cpp
index 1805c5a..767a14a 100644
--- a/src/bgzf_reader.cpp
+++ b/src/bgzf_reader.cpp
@@ -7,6 +7,7 @@
 #include <cassert>
 #include <cerrno>
 #include <cstdint>
+#include <cstdio>
 #include <cstring>
 #include <filesystem>
 #include <memory>
@@ -28,6 +29,7 @@ get_unaligned_le32(const auto p) -> std::int32_t {
 get_isize(const auto data, const auto data_size) {
   static constexpr decltype(data_size) isize_size = 4;
   assert(data_size > isize_size);
+  // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
   const auto data_isize = data + data_size - isize_size;
   return data_size < isize_size ? 0 : get_unaligned_le32(data_isize);
 }
@@ -50,7 +52,8 @@ bgzf_reader::bgzf_reader(const std::string &filename,
   next_in{inbuf.get()},                                       //
   end_in{inbuf.get()},                                        //
   next_out{outbuf.get()},                                     //
-  end_out{outbuf.get() + buf_size}                            //
+  // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
+  end_out{outbuf.get() + buf_size}  //
 {}
 
 [[nodiscard]] auto
diff --git a/src/contaminants.cpp b/src/contaminants.cpp
index 356879d..d6b64ef 100644
--- a/src/contaminants.cpp
+++ b/src/contaminants.cpp
@@ -11,6 +11,7 @@
 #include <stdexcept>
 #include <string>
 #include <string_view>
+#include <tuple>  // for std::get
 #include <utility>
 #include <vector>
 
@@ -197,7 +198,8 @@ load_contaminants(const std::string &filename) -> void {
       continue;
     line.remove_suffix(std::size(line) - to_keep_suffix - 1);
     std::string cleaned_line;
-    for (auto itr = std::cbegin(line); itr != std::cend(line); ++itr)
+    for (auto itr = std::cbegin(line); itr != std::cend(line);
+         itr = std::next(itr))
       if (!std::isblank(*itr) ||
           (std::next(itr) != std::cend(line) && *itr != *std::next(itr)))
         cleaned_line += *itr;
diff --git a/src/contaminants.hpp b/src/contaminants.hpp
index 186a57e..fba5a64 100644
--- a/src/contaminants.hpp
+++ b/src/contaminants.hpp
@@ -4,6 +4,7 @@
 #define SRC_CONTAMINANTS_HPP_
 
 #include <cstdint>
+#include <ranges>  // for std::pair
 #include <string>
 #include <utility>  // IWYU pragma: keep
 #include <vector>
diff --git a/src/duplication_results.cpp b/src/duplication_results.cpp
index 85d8efb..2e3dd17 100644
--- a/src/duplication_results.cpp
+++ b/src/duplication_results.cpp
@@ -11,6 +11,7 @@
 #include "run_mode.hpp"
 
 #define FMT_HEADER_ONLY
+#include "fmt/base.h"
 #include "fmt/format.h"
 #include "fmt/ranges.h"
 
@@ -124,8 +125,8 @@ duplication_results::get_overrepresented(const std::uint64_t n_reads) const
 }
 
 auto
-duplication_results::initialize(const run_mode &mode,
-                                const file_info &info) -> void {
+duplication_results::initialize(const run_mode &mode, const file_info &info)
+  -> void {
   read_skip =
     info.n_reads_est < max_n_reads_total
       ? 0
@@ -282,8 +283,8 @@ get_grade_duplication(const dup_summary_t &summary) -> std::string {
 }
 
 [[nodiscard]] auto
-duplication_report(const dup_summary_t &summary,
-                   const file_grades &grades) -> std::string {
+duplication_report(const dup_summary_t &summary, const file_grades &grades)
+  -> std::string {
   static constexpr auto label = "duplication";
   static constexpr auto start_tag = ">>Sequence Duplication Levels\t{}\n"
                                     "#Total Deduplicated Percentage\t{:.6f}\n";
@@ -305,9 +306,10 @@ duplication_report(const dup_summary_t &summary,
             std::max(static_cast<std::uint64_t>(1), reduce(summary.hist_mass)));
   auto r = std::format(start_tag, grades.grade(label), pct(frac_dedup));
   r += header;
-  for (const auto [label, mass] :
+  for (const auto [bin_label, mass] :
        std::views::zip(bin_labels, binned_mass_pct) | std::views::drop(1))
-    r += std::format("{}\t{:.3g}\n", label, mass);  // Percentage format is .3g
+    r +=
+      std::format("{}\t{:.3g}\n", bin_label, mass);  // Percentage format is .3g
   return r + end_module_tag;
 }
 
@@ -345,8 +347,8 @@ overrepresented_html(const std::vector<overrep_t> &overrep,
 }
 
 [[nodiscard]] auto
-duplication_html(const dup_summary_t &summary,
-                 const file_grades &grades) -> std::string {
+duplication_html(const dup_summary_t &summary, const file_grades &grades)
+  -> std::string {
   static constexpr auto label = "duplication";
   static constexpr auto plot_format = R"(<div id="duplication_plot"></div>
 <script>Plotly.newPlot("duplication_plot",
@@ -389,11 +391,12 @@ yaxis: {{title: "% of sequences"}},
   };
   const auto grade = grades.grade(label);
   const auto title = grades.get_title(label);
-  return fmt::format(
-    html_module_fmt, grade, label, title, grade,
+  const auto the_plot =
+    // NOLINTNEXTLINE(clang-analyzer-optin.cplusplus.UninitializedObject)
     fmt::format(plot_format,                                          //
                 x, to_pct(summary.hist_mass) | std::views::drop(1),   // y_tot,
                 x, to_pct(summary.hist_dedup) | std::views::drop(1),  // y_dedup
                 x, x_text | std::views::drop(1)  // tickvals
-                ));
+    );
+  return fmt::format(html_module_fmt, grade, label, title, grade, the_plot);
 }
diff --git a/src/duplication_results.hpp b/src/duplication_results.hpp
index a86afc4..75e3f55 100644
--- a/src/duplication_results.hpp
+++ b/src/duplication_results.hpp
@@ -39,7 +39,7 @@ struct dups_init_t {
   std::int64_t count_at_limit{};
   dups_map_t dups_zero;
   dups_init_t() = default;
-  dups_init_t(const dups_map_t &dups) {
+  explicit dups_init_t(const dups_map_t &dups) {
     const auto vals = dups | std::views::values;
     count_at_limit = static_cast<std::int64_t>(
       std::reduce(std::cbegin(vals), std::cend(vals)));
@@ -113,12 +113,12 @@ struct duplication_results {
 get_grade_duplication(const dup_summary_t &summary) -> std::string;
 
 [[nodiscard]] auto
-duplication_report(const dup_summary_t &summary,
-                   const file_grades &grades) -> std::string;
+duplication_report(const dup_summary_t &summary, const file_grades &grades)
+  -> std::string;
 
 [[nodiscard]] auto
-duplication_html(const dup_summary_t &summary,
-                 const file_grades &grades) -> std::string;
+duplication_html(const dup_summary_t &summary, const file_grades &grades)
+  -> std::string;
 
 [[nodiscard]] auto
 get_grade_overrepresented(const std::uint64_t n_reads,
diff --git a/src/falco_analyzer.cpp b/src/falco_analyzer.cpp
index 145a0ec..85672b5 100644
--- a/src/falco_analyzer.cpp
+++ b/src/falco_analyzer.cpp
@@ -20,6 +20,7 @@
 #include <mutex>
 #include <ranges>
 #include <thread>
+#include <tuple>  // for std::get (iwyu fp)
 #include <utility>
 #include <variant>
 #include <vector>
@@ -34,7 +35,6 @@ analyze(const std::uint32_t n_threads, const run_mode &mode,
   const std::int32_t n_files = static_cast<std::int32_t>(std::size(infos));
   if (dups_init.empty())
     dups_init.resize(n_files);
-  std::vector<std::atomic_int32_t> n_tasks(n_files);
   std::atomic_uint32_t n_active_files{static_cast<std::uint32_t>(n_files)};
   auto results =
     std::vector(n_threads, std::vector<results_collector>(n_files));
@@ -45,6 +45,7 @@ analyze(const std::uint32_t n_threads, const run_mode &mode,
     tq.push(file_id, std::monostate{});
 
   {  // scope to join jthreads
+    std::vector<std::atomic_int32_t> n_tasks(n_files);
     std::vector<std::jthread> workers;
     for (const auto th_id : std::views::iota(0u, n_threads))
       workers.emplace_back([&, n_threads, th_id] {
diff --git a/src/falco_config.cpp b/src/falco_config.cpp
index 5989748..a5f6e76 100644
--- a/src/falco_config.cpp
+++ b/src/falco_config.cpp
@@ -41,8 +41,8 @@ split(const std::string &s) {
 }
 
 auto
-load_config_and_set_graders(const std::string &filename,
-                            run_mode &mode) -> void {
+load_config_and_set_graders(const std::string &filename, run_mode &mode)
+  -> void {
   // ADS: (todo) handle carriage returns and other control chars
   std::ifstream in(filename);
   if (!in)
@@ -61,9 +61,10 @@ load_config_and_set_graders(const std::string &filename,
   }
 
   // modes
-  for (const auto &label : run_mode::get_labels())
+  std::ranges::for_each(run_mode::get_labels(), [&](const auto &label) {
     if (json_in.contains(label) && !json_in[label].contains("ignore"))
       throw std::runtime_error("invalid config: " + to_string(json_in[label]));
+  });
 
   std::unordered_map<std::string, bool> modes_in;
   try {
@@ -83,11 +84,12 @@ load_config_and_set_graders(const std::string &filename,
   mode.assign(modes_in);
 
   // grades
-  for (const auto &label : grade_labels)
-    if (json_in.contains(label) &&
-        !(json_in[label].contains("error") && json_in[label].contains("warn")))
-      throw std::runtime_error("missing config value for: " +
-                               std::string(label));
+  std::ranges::for_each(grade_labels, [&](const auto &l) {
+    if (json_in.contains(l) &&
+        !(json_in[l].contains("error") && json_in[l].contains("warn")))
+      throw std::runtime_error("missing config value for: " + std::string(l));
+  });
+
   std::unordered_map<std::string, grader> graders;
   try {
     for (const auto &label : grade_labels) {
diff --git a/src/falco_file_format.cpp b/src/falco_file_format.cpp
index 4c20240..ff4d387 100644
--- a/src/falco_file_format.cpp
+++ b/src/falco_file_format.cpp
@@ -7,7 +7,11 @@
 #include <array>
 #include <cstdlib>
 #include <filesystem>
+#include <iterator>
+#include <memory>
 #include <stdexcept>
+#include <string>
+#include <tuple>
 
 [[nodiscard]] auto
 get_file_format(const std::string &filename)
diff --git a/src/falco_file_format.hpp b/src/falco_file_format.hpp
index 550c82e..9762a42 100644
--- a/src/falco_file_format.hpp
+++ b/src/falco_file_format.hpp
@@ -7,8 +7,6 @@
 
 #include <cstdint>
 #include <format>
-#include <iterator>
-#include <memory>
 #include <string>
 #include <thread>
 #include <tuple>
diff --git a/src/falco_grade.cpp b/src/falco_grade.cpp
index 94796fd..8f1a827 100644
--- a/src/falco_grade.cpp
+++ b/src/falco_grade.cpp
@@ -61,7 +61,7 @@ file_grades::grade(const std::string &label) const -> std::string {
 }
 
 [[nodiscard]] auto
-file_grades::get_title(const std::string &name) const -> std::string {
+file_grades::get_title(const std::string &name) -> std::string {
   const auto itr = std::ranges::find(section_names, name);
   if (itr == std::cend(section_names))
     throw std::runtime_error(std::format("bad section name: {}", name));
@@ -106,8 +106,8 @@ grader_set::get_grader(const std::string &label) -> const grader & {
 }
 
 [[nodiscard]] auto
-grader_set::get_grade(const std::string &label,
-                      const double value) -> std::string {
+grader_set::get_grade(const std::string &label, const double value)
+  -> std::string {
   return get_grader(label).identify_grade(value);
 }
 
@@ -129,7 +129,7 @@ get_grade_sequence_length(const std::vector<std::uint64_t> &lengths)
   static constexpr auto label = "sequence_length";
   if (lengths.empty())
     return grader_set::get_grade(label, 0.0);
-  const bool has_empty_reads = std::size(lengths) > 0 && lengths[0] > 0;
+  const bool has_empty_reads = lengths[0] > 0;
   if (has_empty_reads)
     return "fail";
   const auto n_lengths =
@@ -153,8 +153,8 @@ single_delta(const auto a, const auto b, const auto tot) {
 }
 
 [[nodiscard]] static auto
-get_grade_sequence_impl(const std::vector<falco::nuc_array> &nucs,
-                        auto &&delta) -> std::string {
+get_grade_sequence_impl(const std::vector<falco::nuc_array> &nucs, auto &&delta)
+  -> std::string {
   static constexpr auto label = "sequence";
   if (nucs.empty())
     return grader_set::get_grade(label, 0.0);
diff --git a/src/falco_grade.hpp b/src/falco_grade.hpp
index 903a596..6de9982 100644
--- a/src/falco_grade.hpp
+++ b/src/falco_grade.hpp
@@ -83,8 +83,8 @@ struct file_grades {
   [[nodiscard]] auto
   grade(const std::string &name) const -> std::string;
 
-  [[nodiscard]] auto
-  get_title(const std::string &name) const -> std::string;
+  [[nodiscard]] static auto
+  get_title(const std::string &name) -> std::string;
 
   [[nodiscard]] auto
   to_string(const std::string &infile_path) const -> std::string;
diff --git a/src/falco_utils.cpp b/src/falco_utils.cpp
index f150925..51525e2 100644
--- a/src/falco_utils.cpp
+++ b/src/falco_utils.cpp
@@ -2,6 +2,7 @@
 
 #include "falco_utils.hpp"
 
+#include <algorithm>
 #include <array>
 #include <cmath>
 #include <compare>
diff --git a/src/falco_utils.hpp b/src/falco_utils.hpp
index bd79a80..f8e75bd 100644
--- a/src/falco_utils.hpp
+++ b/src/falco_utils.hpp
@@ -95,7 +95,7 @@ static constexpr std::int64_t gigabytes = 1024 * 1024 * 1024;
 static constexpr std::int64_t megabytes = 1024 * 1024;
 static constexpr std::int64_t kilobytes = 1024;
 
-[[nodiscard]] inline auto
+inline auto
 resize_gc_content(const std::uint32_t updated_length,
                   std::vector<falco::gc_content_t> &gc_content) {
   const auto prev_size = std::size(gc_content);
@@ -340,8 +340,8 @@ five_quants(const auto &a) -> std::array<std::uint32_t, 5> {
 // NOLINTEND(cppcoreguidelines-avoid-magic-numbers)
 
 [[nodiscard]] auto
-size_to_units(const std::int64_t s,
-              const std::string &suffix = "iB") -> std::string;
+size_to_units(const std::int64_t s, const std::string &suffix = "iB")
+  -> std::string;
 
 [[nodiscard]] inline auto
 get_max_size(const auto &x) {
@@ -351,8 +351,8 @@ get_max_size(const auto &x) {
 }
 
 [[nodiscard]] inline auto
-estimate_read_length_fastq_chunk(const auto &data,
-                                 const auto n) -> std::uint64_t {
+estimate_read_length_fastq_chunk(const auto &data, const auto n)
+  -> std::uint64_t {
   static constexpr auto fastq_lines_per_read = 4;
   assert(n >= 1);
   const auto valid = [](const auto c) {
diff --git a/src/falco_word.hpp b/src/falco_word.hpp
index 3a5380b..f4218fa 100644
--- a/src/falco_word.hpp
+++ b/src/falco_word.hpp
@@ -36,6 +36,7 @@ struct falco_word {
       return ((c >> 1) & 7) ^ 3;  // NOLINT(*-avoid-magic-numbers)
     };
     static const auto enc_shift = [&](auto &x, auto &c) {
+      // NOLINTNEXTLINE(clang-analyzer-security.ArrayBound)
       x = (x * extended_alpha_size) + fw_encode(*c++);
     };
     w = w < max_hi_lim ? w : max_hi_lim;
diff --git a/src/fastq_bgzf_file.cpp b/src/fastq_bgzf_file.cpp
index cc8c9fb..8f5ff82 100644
--- a/src/fastq_bgzf_file.cpp
+++ b/src/fastq_bgzf_file.cpp
@@ -21,6 +21,7 @@
 #include <ranges>
 #include <string>
 #include <system_error>
+#include <tuple>  // IWYU pragma: keep
 #include <utility>
 #include <vector>
 
@@ -52,12 +53,12 @@ estimate_n_reads_fastq_bgzf(const std::string &filename)
 }
 
 [[nodiscard]] auto
-init_dups_fq(const std::string &filename,
-             const std::uint64_t n_unique) -> dups_map_t {
+init_dups_fq(const std::string &filename, const std::uint64_t n_unique)
+  -> dups_map_t {
   static constexpr auto n_unique_multiplier = 10;
   std::unique_ptr<BGZF, int (*)(BGZF *)> f(bgzf_open(std::data(filename), "r"),
                                            &bgzf_close);
-  if (!f)
+  if (f.get() == nullptr)
     throw std::system_error(std::make_error_code(std::errc(errno)),
                             "failed to open file: " + filename);
   dups_map_t dups;
@@ -117,6 +118,7 @@ fastq_bgzf_file::get_chunks(const std::int64_t n_chunks,  //
   std::swap(input_last, output_last);
 
   const auto data = std::data(output_buffer);
+  // NOLINTBEGIN(cppcoreguidelines-pro-bounds-pointer-arithmetic)
   const auto not_read_start = [](const auto s, const auto p) {
     // ADS: could get confused if '+' lines have full name info
     return s[p] != '@' || (p > 0 && s[p - 1] != '\n') ||
@@ -134,6 +136,7 @@ fastq_bgzf_file::get_chunks(const std::int64_t n_chunks,  //
       --pos;
     return pos;
   };
+  // NOLINTEND(cppcoreguidelines-pro-bounds-pointer-arithmetic)
   const auto n_bytes_available = output_last;
   const auto [chunk_size, remainder] = std::div(n_bytes_available, n_chunks);
   assert(n_chunks > 0);
diff --git a/src/fastq_file.cpp b/src/fastq_file.cpp
index bf8421b..cd99daf 100644
--- a/src/fastq_file.cpp
+++ b/src/fastq_file.cpp
@@ -10,6 +10,7 @@
 #include <sys/stat.h>
 #include <unistd.h>
 
+#include <algorithm>  // IWYU pragma: keep
 #include <cassert>
 #include <cstdint>
 #include <cstdlib>
@@ -17,6 +18,7 @@
 #include <span>
 #include <string>
 #include <system_error>
+#include <tuple>  // IWYU pragma: keep
 #include <type_traits>
 #include <utility>
 #include <vector>
diff --git a/src/fastq_gz_file.cpp b/src/fastq_gz_file.cpp
index 63cab2b..73460fb 100644
--- a/src/fastq_gz_file.cpp
+++ b/src/fastq_gz_file.cpp
@@ -19,6 +19,7 @@
 #include <ranges>
 #include <string>
 #include <system_error>
+#include <tuple>  // IWYU pragma: keep
 #include <vector>
 
 [[nodiscard]] auto
@@ -57,6 +58,7 @@ fastq_gz_file::get_chunks(const std::int64_t n_chunks,  //
   static constexpr auto rec_lines = 4;  // FASTQ
   assert(n_chunks > 0);
   const auto data = std::data(outbuf);
+  // NOLINTBEGIN(cppcoreguidelines-pro-bounds-pointer-arithmetic)
   const auto not_read_start = [](const auto s, const auto p) {
     // ADS: could get confused if '+' lines have full name info
     return s[p] != '@' || (p > 0 && s[p - 1] != '\n') ||
@@ -74,6 +76,7 @@ fastq_gz_file::get_chunks(const std::int64_t n_chunks,  //
       --p;
     return p;
   };
+  // NOLINTEND(cppcoreguidelines-pro-bounds-pointer-arithmetic)
   const auto n_bytes_available =
     buf_sz - cursor;  // ADS: I think cursor must always be 0 here
   const auto [chunk_size, remainder] = std::div(n_bytes_available, n_chunks);
diff --git a/src/html.cpp b/src/html.cpp
index 6c69921..6a11630 100644
--- a/src/html.cpp
+++ b/src/html.cpp
@@ -23,12 +23,13 @@
 #include <cmath>
 #include <format>
 #include <iterator>
-#include <map>
+#include <map>  // for tile_processor::tiles_centered_t
 #include <numeric>
 #include <ranges>
 #include <span>
 #include <stdexcept>
 #include <string>
+#include <tuple>  // for std::get probably in fmt
 #include <vector>
 
 [[nodiscard]] auto
@@ -368,7 +369,7 @@ basic_stats_html(const file_info &info, const std::uint64_t n_reads,
     html_module_fmt, grade, label, title, grade,
     fmt::format(table_fmt, fmt::arg("filename_stem", info.name),
                 fmt::arg("file_type", info.description),
-                fmt::arg("encoding", to_string(info.encoding)),
+                fmt::arg("encoding", encoding_to_string(info.encoding)),
                 fmt::arg("n_reads", n_reads),
                 fmt::arg("lengths_label", lengths_label),
                 fmt::arg("mean_length", as_frac(total_nucs, n_reads)),
@@ -378,8 +379,8 @@ basic_stats_html(const file_info &info, const std::uint64_t n_reads,
 
 [[nodiscard]] auto
 tile_html(const tile_processor::tiles_centered_t &centered,
-          const std::vector<base_group_t> &groups,
-          const file_grades &grades) -> std::string {
+          const std::vector<base_group_t> &groups, const file_grades &grades)
+  -> std::string {
   static constexpr auto label = "tile";
   static constexpr auto n_quants = 20.0;
   // ADS: ??? (-10: red, 0: light blue, +10: dark blue)
@@ -438,8 +439,8 @@ yaxis: {{title: "tile", type: "category"}},
 }
 
 [[nodiscard]] auto
-kmer_html(const std::vector<kmer_result> &results,
-          const file_grades &grades) -> std::string {
+kmer_html(const std::vector<kmer_result> &results, const file_grades &grades)
+  -> std::string {
   static constexpr auto label = "kmer";
   static constexpr auto plot_format = R"(<div id="kmer_plot"></div>
 <script>Plotly.newPlot("kmer_plot",
@@ -468,10 +469,12 @@ name: "{}",
   };
   const auto grade = grades.grade(label);
   const auto title = grades.get_title(label);
+  // NOLINTBEGIN(clang-analyzer-optin.cplusplus.UninitializedObject)
   return fmt::format(
     html_module_fmt, grade, label, title, grade,
     fmt::format(
       plot_format,
       fmt::format("[{}]",
                   fmt::join(std::views::transform(results, format1), ",\n"))));
+  // NOLINTEND(clang-analyzer-optin.cplusplus.UninitializedObject)
 }
diff --git a/src/kmer_counter.cpp b/src/kmer_counter.cpp
index 2fc57b8..8048a71 100644
--- a/src/kmer_counter.cpp
+++ b/src/kmer_counter.cpp
@@ -174,10 +174,10 @@ kmer_counter::decode_kmer(auto word, const auto n_bases) -> std::string {
   return r;
 }
 
-auto
-kmer_counter::apply_groups([[maybe_unused]] const run_mode &mode) -> void {
-  // ADS: !!! should we be computing the 'results' here?
-}
+// auto
+// kmer_counter::apply_groups([[maybe_unused]] const run_mode &mode) -> void {
+//   // ADS: !!! should we be computing the 'results' here?
+// }
 
 [[nodiscard]] auto
 get_grade_kmer(const std::vector<kmer_result> &results) -> std::string {
diff --git a/src/kmer_counter.hpp b/src/kmer_counter.hpp
index 2013f25..2b5e589 100644
--- a/src/kmer_counter.hpp
+++ b/src/kmer_counter.hpp
@@ -12,8 +12,6 @@
 #include <thread>  // IWYU pragma: keep
 #include <vector>
 
-class run_mode;
-
 struct kmer_result {
   // holds info for {kmer} x {position} to be sorted, filtered and output
   std::uint64_t kmer{};
@@ -83,8 +81,8 @@ struct kmer_counter {
     }
   }
 
-  auto
-  apply_groups(const run_mode &mode) -> void;
+  // auto
+  // apply_groups(const run_mode &mode) -> void;
 
   auto
   operator+=(const kmer_counter &rhs) -> const kmer_counter &;
diff --git a/src/original_duplicates.cpp b/src/original_duplicates.cpp
index 8d9bc26..fba205e 100644
--- a/src/original_duplicates.cpp
+++ b/src/original_duplicates.cpp
@@ -17,6 +17,7 @@
 #include <ranges>
 #include <string>
 #include <thread>
+#include <utility>  // for std::move
 #include <vector>
 
 [[nodiscard]] auto
@@ -55,7 +56,7 @@ initialize_original_duplicates(
   std::ranges::for_each(workers, [](auto &w) { w.join(); });
   std::vector<dups_init_t> ret;
   ret.reserve(n_files);
-  for (const auto &d : dups)
-    ret.emplace_back(d);
+  std::ranges::for_each(dups,
+                        [&](auto &&d) { ret.emplace_back(std::move(d)); });
   return ret;
 }
diff --git a/src/quality_score.cpp b/src/quality_score.cpp
index 3723228..d9e1ce8 100644
--- a/src/quality_score.cpp
+++ b/src/quality_score.cpp
@@ -12,6 +12,7 @@
 #include <iterator>
 #include <ranges>
 #include <stdexcept>
+#include <string>
 #include <utility>
 #include <vector>
 
@@ -70,7 +71,7 @@ adjust_fastq_qual_encoding(std::vector<falco::qual_array> &qual_by_pos,
 }
 
 [[nodiscard]] auto
-to_string(const falco::encoding e) -> std::string {
+encoding_to_string(const falco::encoding e) -> std::string {
   const auto u = std::to_underlying(e);
   assert(u < std::size(falco::format_labels));
   return falco::format_labels[u];  // NOLINT(*-pro-bounds-constant-array-index)
diff --git a/src/quality_score.hpp b/src/quality_score.hpp
index 19db487..5da3656 100644
--- a/src/quality_score.hpp
+++ b/src/quality_score.hpp
@@ -52,7 +52,7 @@ using qual_array = std::array<std::uint64_t, max_qual_val + 1>;
 }  // namespace falco
 
 [[nodiscard]] auto
-to_string(const falco::encoding e) -> std::string;
+encoding_to_string(const falco::encoding e) -> std::string;
 
 [[nodiscard]] auto
 get_quality_score_offset(const falco::encoding e) -> std::int64_t;
diff --git a/src/report.cpp b/src/report.cpp
index 44a9172..0dc8549 100644
--- a/src/report.cpp
+++ b/src/report.cpp
@@ -23,7 +23,6 @@
 #include <format>
 #include <iterator>
 #include <limits>
-#include <map>
 #include <numeric>
 #include <ranges>
 #include <span>
@@ -189,7 +188,7 @@ basic_stats_report(const file_info &info, const std::uint64_t n_reads,
   r += header;
   r += std::format("Filename\t{}\n", info.name);
   r += std::format("File type\t{}\n", info.description);
-  r += std::format("Encoding\t{}\n", to_string(info.encoding));
+  r += std::format("Encoding\t{}\n", encoding_to_string(info.encoding));
   r += std::format("Total Sequences\t{}\n", n_reads);
   r += std::format("Total Bases\t{}\n", total_nucs);
   r += std::format("Sequence length\t{}\n",
@@ -209,8 +208,8 @@ basic_stats_report(const file_info &info, const std::uint64_t n_reads,
 
 [[nodiscard]] auto
 tile_report(const tile_processor::tiles_centered_t &centered,
-            const std::vector<base_group_t> &groups,
-            const file_grades &grades) -> std::string {
+            const std::vector<base_group_t> &groups, const file_grades &grades)
+  -> std::string {
   static constexpr auto label = "tile";
   static constexpr auto max_precision{std::numeric_limits<double>::digits10};
   static constexpr auto start_tag = ">>Per tile sequence quality\t{}\n";
@@ -229,8 +228,8 @@ tile_report(const tile_processor::tiles_centered_t &centered,
 }
 
 [[nodiscard]] auto
-kmer_report(const std::vector<kmer_result> &results,
-            const file_grades &grades) -> std::string {
+kmer_report(const std::vector<kmer_result> &results, const file_grades &grades)
+  -> std::string {
   static constexpr auto label = "kmer";
   static constexpr auto start_tag = ">>Kmer Content\t{}\n";
   static constexpr auto header = "#Sequence\t"
diff --git a/src/results_collector.hpp b/src/results_collector.hpp
index 91dafdb..552b77d 100644
--- a/src/results_collector.hpp
+++ b/src/results_collector.hpp
@@ -134,7 +134,8 @@ struct alignas(assumed_page_size) results_collector {
     const auto seq_end = get_seq_end(rec);
     count_nucs(seq_itr, seq_end, base_counts);
     const auto gc = count_gc(seq_itr, seq_end);
-    assert(get_arr_idx(read_len) < std::ssize(gc_content));
+    assert(static_cast<std::uint64_t>(get_arr_idx(read_len)) <
+           std::size(gc_content));
     ++gc_content[get_arr_idx(read_len)][get_gc_idx(gc, read_len)];
     count_ns(seq_itr, seq_end, n_counts);
     const auto tot = count_quals(get_qual(rec), get_qual_end(rec), qual_by_pos);
@@ -196,17 +197,17 @@ accumulate_results(std::vector<std::vector<results_collector>> &r,
 }
 
 inline auto
-process_reads(results_collector &results, fq_task_t &task) {
+process_reads(results_collector &results, const fq_task_t &task) {
   results.process_reads_fq(task.beg, task.end);
 }
 
 inline auto
-process_reads(results_collector &results, bam_task_t &task) {
+process_reads(results_collector &results, const bam_task_t &task) {
   results.process_reads_bam(task.beg, task.end);
 }
 
 inline auto
-process_reads(results_collector &results, sam_task_t &task) {
+process_reads(results_collector &results, const sam_task_t &task) {
   results.process_reads_sam(task.beg, task.end);
 }
 
diff --git a/src/results_summary.cpp b/src/results_summary.cpp
index d1772b4..be4d724 100644
--- a/src/results_summary.cpp
+++ b/src/results_summary.cpp
@@ -241,7 +241,7 @@ results_summary::get_summary() const -> std::string {
 results_summary::get_preseq_hist() const -> std::string {
   const auto hist = dr.get_preseq_hist();
   std::string r;
-  for (const auto &[n_times_seen, n_reads] : hist)
-    r += std::format("{}\t{}\n", n_times_seen, n_reads);
+  for (const auto &[n_times_seen, hist_n_reads] : hist)
+    r += std::format("{}\t{}\n", n_times_seen, hist_n_reads);
   return r;
 }
diff --git a/src/sam_file.cpp b/src/sam_file.cpp
index f03293d..8fb4ced 100644
--- a/src/sam_file.cpp
+++ b/src/sam_file.cpp
@@ -9,9 +9,11 @@
 #include <cassert>
 #include <cerrno>
 #include <cstdint>
+#include <cstdio>
 #include <iterator>
 #include <ranges>
 #include <stdexcept>
+#include <string>
 #include <system_error>
 
 sam_file::sam_file(const std::string &filename, const std::int64_t buf_size) :
@@ -22,6 +24,8 @@ sam_file::sam_file(const std::string &filename, const std::int64_t buf_size) :
                       "failed to read file");
   if (!skip_header())
     std::runtime_error("failed to validated SAM file header: " + filename);
+  cursor = std::begin(buffer);
+  last = std::begin(buffer);
 }
 
 [[nodiscard]] auto
diff --git a/src/samrec.cpp b/src/samrec.cpp
index 7368fde..14ff8a9 100644
--- a/src/samrec.cpp
+++ b/src/samrec.cpp
@@ -11,6 +11,7 @@
 #include <memory>
 #include <span>
 #include <stdexcept>
+#include <string>
 #include <system_error>
 
 #ifdef BAM_FREVERSE
diff --git a/src/tile_processor.cpp b/src/tile_processor.cpp
index 11a4654..fb3e9ed 100644
--- a/src/tile_processor.cpp
+++ b/src/tile_processor.cpp
@@ -14,9 +14,6 @@
 #include <htslib/bgzf.h>
 #include <htslib/sam.h>
 
-#define FMT_HEADER_ONLY
-#include "fmt/format.h"
-
 #include <algorithm>
 #include <cassert>
 #include <cstdint>
@@ -28,6 +25,7 @@
 #include <ranges>
 #include <stdexcept>
 #include <string>
+#include <tuple>  // for std::get
 #include <utility>
 #include <vector>
 
@@ -170,18 +168,19 @@ tile_processor::add_and_consume(
   const auto pair_plus = [](const auto &a, const auto &b) {
     return std::pair{a.first + b.first, a.second + b.second};
   };
-  for (auto &[tile_id, rhs_qual] : rhs.quals) {
-    const auto quals_itr = quals.find(tile_id);
+  for (auto &[rhs_tile_id, rhs_qual] : rhs.quals) {
+    const auto quals_itr = quals.find(rhs_tile_id);
     if (quals_itr != std::end(quals)) {
-      auto &qual = quals_itr->second;
-      if (std::size(rhs_qual) > std::size(qual))
-        std::swap(rhs_qual, qual);
-      std::ranges::transform(qual, rhs_qual, std::begin(qual), pair_plus);
+      auto &curr_qual = quals_itr->second;
+      if (std::size(rhs_qual) > std::size(curr_qual))
+        std::swap(rhs_qual, curr_qual);
+      std::ranges::transform(curr_qual, rhs_qual, std::begin(curr_qual),
+                             pair_plus);
       rhs_qual.clear();
       rhs_qual.shrink_to_fit();
     }
     else
-      quals.emplace(tile_id, std::move(rhs_qual));
+      quals.emplace(rhs_tile_id, std::move(rhs_qual));
   }
   rhs.release();
 }